Termination of the following Term Rewriting System could not be shown:

Context-sensitive rewrite system:
The TRS R consists of the following rules:

U101(tt, N, XS) → fst(splitAt(N, XS))
U11(tt, N, XS) → snd(splitAt(N, XS))
U21(tt, X) → X
U31(tt, N) → N
U41(tt, N) → cons(N, natsFrom(s(N)))
U51(tt, N, XS) → head(afterNth(N, XS))
U61(tt, Y) → Y
U71(tt, XS) → pair(nil, XS)
U81(tt, N, X, XS) → U82(splitAt(N, XS), X)
U82(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
U91(tt, XS) → XS
afterNth(N, XS) → U11(and(isNatural(N), isLNat(XS)), N, XS)
and(tt, X) → X
fst(pair(X, Y)) → U21(and(isLNat(X), isLNat(Y)), X)
head(cons(N, XS)) → U31(and(isNatural(N), isLNat(XS)), N)
isLNat(nil) → tt
isLNat(afterNth(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(cons(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(fst(V1)) → isPLNat(V1)
isLNat(natsFrom(V1)) → isNatural(V1)
isLNat(snd(V1)) → isPLNat(V1)
isLNat(tail(V1)) → isLNat(V1)
isLNat(take(V1, V2)) → and(isNatural(V1), isLNat(V2))
isNatural(0) → tt
isNatural(head(V1)) → isLNat(V1)
isNatural(s(V1)) → isNatural(V1)
isNatural(sel(V1, V2)) → and(isNatural(V1), isLNat(V2))
isPLNat(pair(V1, V2)) → and(isLNat(V1), isLNat(V2))
isPLNat(splitAt(V1, V2)) → and(isNatural(V1), isLNat(V2))
natsFrom(N) → U41(isNatural(N), N)
sel(N, XS) → U51(and(isNatural(N), isLNat(XS)), N, XS)
snd(pair(X, Y)) → U61(and(isLNat(X), isLNat(Y)), Y)
splitAt(0, XS) → U71(isLNat(XS), XS)
splitAt(s(N), cons(X, XS)) → U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tail(cons(N, XS)) → U91(and(isNatural(N), isLNat(XS)), XS)
take(N, XS) → U101(and(isNatural(N), isLNat(XS)), N, XS)

The replacement map contains the following entries:

U101: {1}
tt: empty set
fst: {1}
splitAt: {1, 2}
U11: {1}
snd: {1}
U21: {1}
U31: {1}
U41: {1}
cons: {1}
natsFrom: {1}
s: {1}
U51: {1}
head: {1}
afterNth: {1, 2}
U61: {1}
U71: {1}
pair: {1, 2}
nil: empty set
U81: {1}
U82: {1}
U91: {1}
and: {1}
isNatural: empty set
isLNat: empty set
isPLNat: empty set
tail: {1}
take: {1, 2}
0: empty set
sel: {1, 2}


↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Context-sensitive rewrite system:
The TRS R consists of the following rules:

U101(tt, N, XS) → fst(splitAt(N, XS))
U11(tt, N, XS) → snd(splitAt(N, XS))
U21(tt, X) → X
U31(tt, N) → N
U41(tt, N) → cons(N, natsFrom(s(N)))
U51(tt, N, XS) → head(afterNth(N, XS))
U61(tt, Y) → Y
U71(tt, XS) → pair(nil, XS)
U81(tt, N, X, XS) → U82(splitAt(N, XS), X)
U82(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
U91(tt, XS) → XS
afterNth(N, XS) → U11(and(isNatural(N), isLNat(XS)), N, XS)
and(tt, X) → X
fst(pair(X, Y)) → U21(and(isLNat(X), isLNat(Y)), X)
head(cons(N, XS)) → U31(and(isNatural(N), isLNat(XS)), N)
isLNat(nil) → tt
isLNat(afterNth(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(cons(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(fst(V1)) → isPLNat(V1)
isLNat(natsFrom(V1)) → isNatural(V1)
isLNat(snd(V1)) → isPLNat(V1)
isLNat(tail(V1)) → isLNat(V1)
isLNat(take(V1, V2)) → and(isNatural(V1), isLNat(V2))
isNatural(0) → tt
isNatural(head(V1)) → isLNat(V1)
isNatural(s(V1)) → isNatural(V1)
isNatural(sel(V1, V2)) → and(isNatural(V1), isLNat(V2))
isPLNat(pair(V1, V2)) → and(isLNat(V1), isLNat(V2))
isPLNat(splitAt(V1, V2)) → and(isNatural(V1), isLNat(V2))
natsFrom(N) → U41(isNatural(N), N)
sel(N, XS) → U51(and(isNatural(N), isLNat(XS)), N, XS)
snd(pair(X, Y)) → U61(and(isLNat(X), isLNat(Y)), Y)
splitAt(0, XS) → U71(isLNat(XS), XS)
splitAt(s(N), cons(X, XS)) → U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tail(cons(N, XS)) → U91(and(isNatural(N), isLNat(XS)), XS)
take(N, XS) → U101(and(isNatural(N), isLNat(XS)), N, XS)

The replacement map contains the following entries:

U101: {1}
tt: empty set
fst: {1}
splitAt: {1, 2}
U11: {1}
snd: {1}
U21: {1}
U31: {1}
U41: {1}
cons: {1}
natsFrom: {1}
s: {1}
U51: {1}
head: {1}
afterNth: {1, 2}
U61: {1}
U71: {1}
pair: {1, 2}
nil: empty set
U81: {1}
U82: {1}
U91: {1}
and: {1}
isNatural: empty set
isLNat: empty set
isPLNat: empty set
tail: {1}
take: {1, 2}
0: empty set
sel: {1, 2}

Using Improved CS-DPs we result in the following initial Q-CSDP problem.

↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {fst, splitAt, snd, natsFrom, s, head, afterNth, pair, tail, take, sel, FST, SPLITAT, SND, HEAD, AFTERNTH, NATSFROM, SEL, TAIL, TAKE} are replacing on all positions.
For all symbols f in {U101, U11, U21, U31, U41, cons, U51, U61, U71, U81, U82, U91, and, U1011, U111, U511, U821, U811, AND, U211, U311, U411, U611, U711, U911} we have µ(f) = {1}.
The symbols in {isNatural, isLNat, isPLNat, ISNATURAL, ISLNAT, ISPLNAT, U} are not replacing on any position.

The ordinary context-sensitive dependency pairs DPo are:

U1011(tt, N, XS) → FST(splitAt(N, XS))
U1011(tt, N, XS) → SPLITAT(N, XS)
U111(tt, N, XS) → SND(splitAt(N, XS))
U111(tt, N, XS) → SPLITAT(N, XS)
U511(tt, N, XS) → HEAD(afterNth(N, XS))
U511(tt, N, XS) → AFTERNTH(N, XS)
U811(tt, N, X, XS) → U821(splitAt(N, XS), X)
U811(tt, N, X, XS) → SPLITAT(N, XS)
AFTERNTH(N, XS) → U111(and(isNatural(N), isLNat(XS)), N, XS)
AFTERNTH(N, XS) → AND(isNatural(N), isLNat(XS))
AFTERNTH(N, XS) → ISNATURAL(N)
FST(pair(X, Y)) → U211(and(isLNat(X), isLNat(Y)), X)
FST(pair(X, Y)) → AND(isLNat(X), isLNat(Y))
FST(pair(X, Y)) → ISLNAT(X)
HEAD(cons(N, XS)) → U311(and(isNatural(N), isLNat(XS)), N)
HEAD(cons(N, XS)) → AND(isNatural(N), isLNat(XS))
HEAD(cons(N, XS)) → ISNATURAL(N)
ISLNAT(afterNth(V1, V2)) → AND(isNatural(V1), isLNat(V2))
ISLNAT(afterNth(V1, V2)) → ISNATURAL(V1)
ISLNAT(cons(V1, V2)) → AND(isNatural(V1), isLNat(V2))
ISLNAT(cons(V1, V2)) → ISNATURAL(V1)
ISLNAT(fst(V1)) → ISPLNAT(V1)
ISLNAT(natsFrom(V1)) → ISNATURAL(V1)
ISLNAT(snd(V1)) → ISPLNAT(V1)
ISLNAT(tail(V1)) → ISLNAT(V1)
ISLNAT(take(V1, V2)) → AND(isNatural(V1), isLNat(V2))
ISLNAT(take(V1, V2)) → ISNATURAL(V1)
ISNATURAL(head(V1)) → ISLNAT(V1)
ISNATURAL(s(V1)) → ISNATURAL(V1)
ISNATURAL(sel(V1, V2)) → AND(isNatural(V1), isLNat(V2))
ISNATURAL(sel(V1, V2)) → ISNATURAL(V1)
ISPLNAT(pair(V1, V2)) → AND(isLNat(V1), isLNat(V2))
ISPLNAT(pair(V1, V2)) → ISLNAT(V1)
ISPLNAT(splitAt(V1, V2)) → AND(isNatural(V1), isLNat(V2))
ISPLNAT(splitAt(V1, V2)) → ISNATURAL(V1)
NATSFROM(N) → U411(isNatural(N), N)
NATSFROM(N) → ISNATURAL(N)
SEL(N, XS) → U511(and(isNatural(N), isLNat(XS)), N, XS)
SEL(N, XS) → AND(isNatural(N), isLNat(XS))
SEL(N, XS) → ISNATURAL(N)
SND(pair(X, Y)) → U611(and(isLNat(X), isLNat(Y)), Y)
SND(pair(X, Y)) → AND(isLNat(X), isLNat(Y))
SND(pair(X, Y)) → ISLNAT(X)
SPLITAT(0, XS) → U711(isLNat(XS), XS)
SPLITAT(0, XS) → ISLNAT(XS)
SPLITAT(s(N), cons(X, XS)) → U811(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS)
SPLITAT(s(N), cons(X, XS)) → AND(isNatural(N), and(isNatural(X), isLNat(XS)))
SPLITAT(s(N), cons(X, XS)) → ISNATURAL(N)
TAIL(cons(N, XS)) → U911(and(isNatural(N), isLNat(XS)), XS)
TAIL(cons(N, XS)) → AND(isNatural(N), isLNat(XS))
TAIL(cons(N, XS)) → ISNATURAL(N)
TAKE(N, XS) → U1011(and(isNatural(N), isLNat(XS)), N, XS)
TAKE(N, XS) → AND(isNatural(N), isLNat(XS))
TAKE(N, XS) → ISNATURAL(N)

The collapsing dependency pairs are DPc:

U1011(tt, N, XS) → N
U1011(tt, N, XS) → XS
U111(tt, N, XS) → N
U111(tt, N, XS) → XS
U211(tt, X) → X
U311(tt, N) → N
U411(tt, N) → N
U511(tt, N, XS) → N
U511(tt, N, XS) → XS
U611(tt, Y) → Y
U711(tt, XS) → XS
U811(tt, N, X, XS) → N
U811(tt, N, X, XS) → XS
U821(pair(YS, ZS), X) → X
U911(tt, XS) → XS
AND(tt, X) → X


The hidden terms of R are:

natsFrom(s(N))
isLNat(V2)

Every hiding context is built from:

s on positions {1}
natsFrom on positions {1}
and on positions {1}

Hence, the new unhiding pairs DPu are :

U1011(tt, N, XS) → U(N)
U1011(tt, N, XS) → U(XS)
U111(tt, N, XS) → U(N)
U111(tt, N, XS) → U(XS)
U211(tt, X) → U(X)
U311(tt, N) → U(N)
U411(tt, N) → U(N)
U511(tt, N, XS) → U(N)
U511(tt, N, XS) → U(XS)
U611(tt, Y) → U(Y)
U711(tt, XS) → U(XS)
U811(tt, N, X, XS) → U(N)
U811(tt, N, X, XS) → U(XS)
U821(pair(YS, ZS), X) → U(X)
U911(tt, XS) → U(XS)
AND(tt, X) → U(X)
U(s(x_0)) → U(x_0)
U(natsFrom(x_0)) → U(x_0)
U(and(x_0, x_1)) → U(x_0)
U(natsFrom(s(N))) → NATSFROM(s(N))
U(isLNat(V2)) → ISLNAT(V2)

The TRS R consists of the following rules:

U101(tt, N, XS) → fst(splitAt(N, XS))
U11(tt, N, XS) → snd(splitAt(N, XS))
U21(tt, X) → X
U31(tt, N) → N
U41(tt, N) → cons(N, natsFrom(s(N)))
U51(tt, N, XS) → head(afterNth(N, XS))
U61(tt, Y) → Y
U71(tt, XS) → pair(nil, XS)
U81(tt, N, X, XS) → U82(splitAt(N, XS), X)
U82(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
U91(tt, XS) → XS
afterNth(N, XS) → U11(and(isNatural(N), isLNat(XS)), N, XS)
and(tt, X) → X
fst(pair(X, Y)) → U21(and(isLNat(X), isLNat(Y)), X)
head(cons(N, XS)) → U31(and(isNatural(N), isLNat(XS)), N)
isLNat(nil) → tt
isLNat(afterNth(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(cons(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(fst(V1)) → isPLNat(V1)
isLNat(natsFrom(V1)) → isNatural(V1)
isLNat(snd(V1)) → isPLNat(V1)
isLNat(tail(V1)) → isLNat(V1)
isLNat(take(V1, V2)) → and(isNatural(V1), isLNat(V2))
isNatural(0) → tt
isNatural(head(V1)) → isLNat(V1)
isNatural(s(V1)) → isNatural(V1)
isNatural(sel(V1, V2)) → and(isNatural(V1), isLNat(V2))
isPLNat(pair(V1, V2)) → and(isLNat(V1), isLNat(V2))
isPLNat(splitAt(V1, V2)) → and(isNatural(V1), isLNat(V2))
natsFrom(N) → U41(isNatural(N), N)
sel(N, XS) → U51(and(isNatural(N), isLNat(XS)), N, XS)
snd(pair(X, Y)) → U61(and(isLNat(X), isLNat(Y)), Y)
splitAt(0, XS) → U71(isLNat(XS), XS)
splitAt(s(N), cons(X, XS)) → U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tail(cons(N, XS)) → U91(and(isNatural(N), isLNat(XS)), XS)
take(N, XS) → U101(and(isNatural(N), isLNat(XS)), N, XS)

Q is empty.

The approximation of the Context-Sensitive Dependency Graph contains 2 SCCs with 46 less nodes.


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPNarrowingProcessor
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {fst, splitAt, snd, natsFrom, s, head, afterNth, pair, tail, take, sel, NATSFROM} are replacing on all positions.
For all symbols f in {U101, U11, U21, U31, U41, cons, U51, U61, U71, U81, U82, U91, and, U411, AND} we have µ(f) = {1}.
The symbols in {isNatural, isLNat, isPLNat, U, ISLNAT, ISNATURAL, ISPLNAT} are not replacing on any position.

The TRS P consists of the following rules:

U(s(x_0)) → U(x_0)
U(natsFrom(x_0)) → U(x_0)
U(and(x_0, x_1)) → U(x_0)
U(natsFrom(s(N))) → NATSFROM(s(N))
NATSFROM(N) → U411(isNatural(N), N)
U411(tt, N) → U(N)
U(isLNat(V2)) → ISLNAT(V2)
ISLNAT(afterNth(V1, V2)) → AND(isNatural(V1), isLNat(V2))
AND(tt, X) → U(X)
ISLNAT(afterNth(V1, V2)) → ISNATURAL(V1)
ISNATURAL(head(V1)) → ISLNAT(V1)
ISLNAT(cons(V1, V2)) → AND(isNatural(V1), isLNat(V2))
ISLNAT(cons(V1, V2)) → ISNATURAL(V1)
ISNATURAL(s(V1)) → ISNATURAL(V1)
ISNATURAL(sel(V1, V2)) → AND(isNatural(V1), isLNat(V2))
ISNATURAL(sel(V1, V2)) → ISNATURAL(V1)
ISLNAT(fst(V1)) → ISPLNAT(V1)
ISPLNAT(pair(V1, V2)) → AND(isLNat(V1), isLNat(V2))
ISPLNAT(pair(V1, V2)) → ISLNAT(V1)
ISLNAT(natsFrom(V1)) → ISNATURAL(V1)
ISLNAT(snd(V1)) → ISPLNAT(V1)
ISPLNAT(splitAt(V1, V2)) → AND(isNatural(V1), isLNat(V2))
ISPLNAT(splitAt(V1, V2)) → ISNATURAL(V1)
ISLNAT(tail(V1)) → ISLNAT(V1)
ISLNAT(take(V1, V2)) → AND(isNatural(V1), isLNat(V2))
ISLNAT(take(V1, V2)) → ISNATURAL(V1)
NATSFROM(N) → ISNATURAL(N)

The TRS R consists of the following rules:

U101(tt, N, XS) → fst(splitAt(N, XS))
U11(tt, N, XS) → snd(splitAt(N, XS))
U21(tt, X) → X
U31(tt, N) → N
U41(tt, N) → cons(N, natsFrom(s(N)))
U51(tt, N, XS) → head(afterNth(N, XS))
U61(tt, Y) → Y
U71(tt, XS) → pair(nil, XS)
U81(tt, N, X, XS) → U82(splitAt(N, XS), X)
U82(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
U91(tt, XS) → XS
afterNth(N, XS) → U11(and(isNatural(N), isLNat(XS)), N, XS)
and(tt, X) → X
fst(pair(X, Y)) → U21(and(isLNat(X), isLNat(Y)), X)
head(cons(N, XS)) → U31(and(isNatural(N), isLNat(XS)), N)
isLNat(nil) → tt
isLNat(afterNth(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(cons(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(fst(V1)) → isPLNat(V1)
isLNat(natsFrom(V1)) → isNatural(V1)
isLNat(snd(V1)) → isPLNat(V1)
isLNat(tail(V1)) → isLNat(V1)
isLNat(take(V1, V2)) → and(isNatural(V1), isLNat(V2))
isNatural(0) → tt
isNatural(head(V1)) → isLNat(V1)
isNatural(s(V1)) → isNatural(V1)
isNatural(sel(V1, V2)) → and(isNatural(V1), isLNat(V2))
isPLNat(pair(V1, V2)) → and(isLNat(V1), isLNat(V2))
isPLNat(splitAt(V1, V2)) → and(isNatural(V1), isLNat(V2))
natsFrom(N) → U41(isNatural(N), N)
sel(N, XS) → U51(and(isNatural(N), isLNat(XS)), N, XS)
snd(pair(X, Y)) → U61(and(isLNat(X), isLNat(Y)), Y)
splitAt(0, XS) → U71(isLNat(XS), XS)
splitAt(s(N), cons(X, XS)) → U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tail(cons(N, XS)) → U91(and(isNatural(N), isLNat(XS)), XS)
take(N, XS) → U101(and(isNatural(N), isLNat(XS)), N, XS)

Q is empty.

Using the Context-Sensitive Narrowing Processor
the pair ISLNAT(afterNth(V1, V2)) → AND(isNatural(V1), isLNat(V2))
was transformed to the following new pairs:

ISLNAT(afterNth(0, y1)) → AND(tt, isLNat(y1))
ISLNAT(afterNth(head(x0), y1)) → AND(isLNat(x0), isLNat(y1))
ISLNAT(afterNth(s(x0), y1)) → AND(isNatural(x0), isLNat(y1))
ISLNAT(afterNth(sel(x0, x1), y1)) → AND(and(isNatural(x0), isLNat(x1)), isLNat(y1))



↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPNarrowingProcessor
              ↳ QCSDP
                ↳ QCSDPNarrowingProcessor
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {fst, splitAt, snd, natsFrom, s, head, afterNth, pair, tail, take, sel, NATSFROM} are replacing on all positions.
For all symbols f in {U101, U11, U21, U31, U41, cons, U51, U61, U71, U81, U82, U91, and, AND, U411} we have µ(f) = {1}.
The symbols in {isNatural, isLNat, isPLNat, ISNATURAL, ISLNAT, U, ISPLNAT} are not replacing on any position.

The TRS P consists of the following rules:

ISLNAT(cons(V1, V2)) → ISNATURAL(V1)
ISLNAT(afterNth(s(x0), y1)) → AND(isNatural(x0), isLNat(y1))
ISNATURAL(sel(V1, V2)) → AND(isNatural(V1), isLNat(V2))
AND(tt, X) → U(X)
ISLNAT(afterNth(0, y1)) → AND(tt, isLNat(y1))
ISPLNAT(splitAt(V1, V2)) → AND(isNatural(V1), isLNat(V2))
ISLNAT(afterNth(sel(x0, x1), y1)) → AND(and(isNatural(x0), isLNat(x1)), isLNat(y1))
NATSFROM(N) → ISNATURAL(N)
ISLNAT(afterNth(head(x0), y1)) → AND(isLNat(x0), isLNat(y1))
U(natsFrom(x_0)) → U(x_0)
ISPLNAT(pair(V1, V2)) → AND(isLNat(V1), isLNat(V2))
ISLNAT(natsFrom(V1)) → ISNATURAL(V1)
ISLNAT(fst(V1)) → ISPLNAT(V1)
U(s(x_0)) → U(x_0)
ISNATURAL(sel(V1, V2)) → ISNATURAL(V1)
ISLNAT(cons(V1, V2)) → AND(isNatural(V1), isLNat(V2))
ISPLNAT(splitAt(V1, V2)) → ISNATURAL(V1)
U(natsFrom(s(N))) → NATSFROM(s(N))
ISLNAT(take(V1, V2)) → AND(isNatural(V1), isLNat(V2))
U411(tt, N) → U(N)
U(and(x_0, x_1)) → U(x_0)
ISLNAT(tail(V1)) → ISLNAT(V1)
ISLNAT(snd(V1)) → ISPLNAT(V1)
U(isLNat(V2)) → ISLNAT(V2)
ISLNAT(take(V1, V2)) → ISNATURAL(V1)
NATSFROM(N) → U411(isNatural(N), N)
ISNATURAL(s(V1)) → ISNATURAL(V1)
ISPLNAT(pair(V1, V2)) → ISLNAT(V1)
ISNATURAL(head(V1)) → ISLNAT(V1)
ISLNAT(afterNth(V1, V2)) → ISNATURAL(V1)

The TRS R consists of the following rules:

U101(tt, N, XS) → fst(splitAt(N, XS))
U11(tt, N, XS) → snd(splitAt(N, XS))
U21(tt, X) → X
U31(tt, N) → N
U41(tt, N) → cons(N, natsFrom(s(N)))
U51(tt, N, XS) → head(afterNth(N, XS))
U61(tt, Y) → Y
U71(tt, XS) → pair(nil, XS)
U81(tt, N, X, XS) → U82(splitAt(N, XS), X)
U82(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
U91(tt, XS) → XS
afterNth(N, XS) → U11(and(isNatural(N), isLNat(XS)), N, XS)
and(tt, X) → X
fst(pair(X, Y)) → U21(and(isLNat(X), isLNat(Y)), X)
head(cons(N, XS)) → U31(and(isNatural(N), isLNat(XS)), N)
isLNat(nil) → tt
isLNat(afterNth(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(cons(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(fst(V1)) → isPLNat(V1)
isLNat(natsFrom(V1)) → isNatural(V1)
isLNat(snd(V1)) → isPLNat(V1)
isLNat(tail(V1)) → isLNat(V1)
isLNat(take(V1, V2)) → and(isNatural(V1), isLNat(V2))
isNatural(0) → tt
isNatural(head(V1)) → isLNat(V1)
isNatural(s(V1)) → isNatural(V1)
isNatural(sel(V1, V2)) → and(isNatural(V1), isLNat(V2))
isPLNat(pair(V1, V2)) → and(isLNat(V1), isLNat(V2))
isPLNat(splitAt(V1, V2)) → and(isNatural(V1), isLNat(V2))
natsFrom(N) → U41(isNatural(N), N)
sel(N, XS) → U51(and(isNatural(N), isLNat(XS)), N, XS)
snd(pair(X, Y)) → U61(and(isLNat(X), isLNat(Y)), Y)
splitAt(0, XS) → U71(isLNat(XS), XS)
splitAt(s(N), cons(X, XS)) → U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tail(cons(N, XS)) → U91(and(isNatural(N), isLNat(XS)), XS)
take(N, XS) → U101(and(isNatural(N), isLNat(XS)), N, XS)

Q is empty.

Using the Context-Sensitive Narrowing Processor
the pair ISLNAT(afterNth(s(x0), y1)) → AND(isNatural(x0), isLNat(y1))
was transformed to the following new pairs:

ISLNAT(afterNth(s(0), y1)) → AND(tt, isLNat(y1))
ISLNAT(afterNth(s(head(x0)), y1)) → AND(isLNat(x0), isLNat(y1))
ISLNAT(afterNth(s(s(x0)), y1)) → AND(isNatural(x0), isLNat(y1))
ISLNAT(afterNth(s(sel(x0, x1)), y1)) → AND(and(isNatural(x0), isLNat(x1)), isLNat(y1))



↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
            ↳ QCSDPNarrowingProcessor
              ↳ QCSDP
                ↳ QCSDPNarrowingProcessor
                  ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {fst, splitAt, snd, natsFrom, s, head, afterNth, pair, tail, take, sel, NATSFROM} are replacing on all positions.
For all symbols f in {U101, U11, U21, U31, U41, cons, U51, U61, U71, U81, U82, U91, and, AND, U411} we have µ(f) = {1}.
The symbols in {isNatural, isLNat, isPLNat, ISNATURAL, ISLNAT, U, ISPLNAT} are not replacing on any position.

The TRS P consists of the following rules:

ISLNAT(cons(V1, V2)) → ISNATURAL(V1)
AND(tt, X) → U(X)
ISNATURAL(sel(V1, V2)) → AND(isNatural(V1), isLNat(V2))
ISLNAT(afterNth(s(0), y1)) → AND(tt, isLNat(y1))
ISPLNAT(splitAt(V1, V2)) → AND(isNatural(V1), isLNat(V2))
ISLNAT(afterNth(0, y1)) → AND(tt, isLNat(y1))
NATSFROM(N) → ISNATURAL(N)
ISLNAT(afterNth(sel(x0, x1), y1)) → AND(and(isNatural(x0), isLNat(x1)), isLNat(y1))
ISLNAT(afterNth(head(x0), y1)) → AND(isLNat(x0), isLNat(y1))
U(natsFrom(x_0)) → U(x_0)
ISPLNAT(pair(V1, V2)) → AND(isLNat(V1), isLNat(V2))
ISLNAT(afterNth(s(head(x0)), y1)) → AND(isLNat(x0), isLNat(y1))
ISLNAT(natsFrom(V1)) → ISNATURAL(V1)
ISLNAT(fst(V1)) → ISPLNAT(V1)
U(s(x_0)) → U(x_0)
ISLNAT(cons(V1, V2)) → AND(isNatural(V1), isLNat(V2))
ISNATURAL(sel(V1, V2)) → ISNATURAL(V1)
ISPLNAT(splitAt(V1, V2)) → ISNATURAL(V1)
U(natsFrom(s(N))) → NATSFROM(s(N))
U411(tt, N) → U(N)
ISLNAT(take(V1, V2)) → AND(isNatural(V1), isLNat(V2))
U(and(x_0, x_1)) → U(x_0)
ISLNAT(snd(V1)) → ISPLNAT(V1)
ISLNAT(tail(V1)) → ISLNAT(V1)
U(isLNat(V2)) → ISLNAT(V2)
ISLNAT(take(V1, V2)) → ISNATURAL(V1)
NATSFROM(N) → U411(isNatural(N), N)
ISLNAT(afterNth(s(s(x0)), y1)) → AND(isNatural(x0), isLNat(y1))
ISNATURAL(s(V1)) → ISNATURAL(V1)
ISPLNAT(pair(V1, V2)) → ISLNAT(V1)
ISNATURAL(head(V1)) → ISLNAT(V1)
ISLNAT(afterNth(V1, V2)) → ISNATURAL(V1)
ISLNAT(afterNth(s(sel(x0, x1)), y1)) → AND(and(isNatural(x0), isLNat(x1)), isLNat(y1))

The TRS R consists of the following rules:

U101(tt, N, XS) → fst(splitAt(N, XS))
U11(tt, N, XS) → snd(splitAt(N, XS))
U21(tt, X) → X
U31(tt, N) → N
U41(tt, N) → cons(N, natsFrom(s(N)))
U51(tt, N, XS) → head(afterNth(N, XS))
U61(tt, Y) → Y
U71(tt, XS) → pair(nil, XS)
U81(tt, N, X, XS) → U82(splitAt(N, XS), X)
U82(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
U91(tt, XS) → XS
afterNth(N, XS) → U11(and(isNatural(N), isLNat(XS)), N, XS)
and(tt, X) → X
fst(pair(X, Y)) → U21(and(isLNat(X), isLNat(Y)), X)
head(cons(N, XS)) → U31(and(isNatural(N), isLNat(XS)), N)
isLNat(nil) → tt
isLNat(afterNth(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(cons(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(fst(V1)) → isPLNat(V1)
isLNat(natsFrom(V1)) → isNatural(V1)
isLNat(snd(V1)) → isPLNat(V1)
isLNat(tail(V1)) → isLNat(V1)
isLNat(take(V1, V2)) → and(isNatural(V1), isLNat(V2))
isNatural(0) → tt
isNatural(head(V1)) → isLNat(V1)
isNatural(s(V1)) → isNatural(V1)
isNatural(sel(V1, V2)) → and(isNatural(V1), isLNat(V2))
isPLNat(pair(V1, V2)) → and(isLNat(V1), isLNat(V2))
isPLNat(splitAt(V1, V2)) → and(isNatural(V1), isLNat(V2))
natsFrom(N) → U41(isNatural(N), N)
sel(N, XS) → U51(and(isNatural(N), isLNat(XS)), N, XS)
snd(pair(X, Y)) → U61(and(isLNat(X), isLNat(Y)), Y)
splitAt(0, XS) → U71(isLNat(XS), XS)
splitAt(s(N), cons(X, XS)) → U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tail(cons(N, XS)) → U91(and(isNatural(N), isLNat(XS)), XS)
take(N, XS) → U101(and(isNatural(N), isLNat(XS)), N, XS)

Q is empty.


↳ CSR
  ↳ CSDependencyPairsProof
    ↳ QCSDP
      ↳ QCSDependencyGraphProof
        ↳ AND
          ↳ QCSDP
          ↳ QCSDP
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation

Q-restricted context-sensitive dependency pair problem:
The symbols in {fst, splitAt, snd, natsFrom, s, head, afterNth, pair, tail, take, sel, SPLITAT} are replacing on all positions.
For all symbols f in {U101, U11, U21, U31, U41, cons, U51, U61, U71, U81, U82, U91, and, U811} we have µ(f) = {1}.
The symbols in {isNatural, isLNat, isPLNat} are not replacing on any position.

The TRS P consists of the following rules:

SPLITAT(s(N), cons(X, XS)) → U811(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS)
U811(tt, N, X, XS) → SPLITAT(N, XS)

The TRS R consists of the following rules:

U101(tt, N, XS) → fst(splitAt(N, XS))
U11(tt, N, XS) → snd(splitAt(N, XS))
U21(tt, X) → X
U31(tt, N) → N
U41(tt, N) → cons(N, natsFrom(s(N)))
U51(tt, N, XS) → head(afterNth(N, XS))
U61(tt, Y) → Y
U71(tt, XS) → pair(nil, XS)
U81(tt, N, X, XS) → U82(splitAt(N, XS), X)
U82(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
U91(tt, XS) → XS
afterNth(N, XS) → U11(and(isNatural(N), isLNat(XS)), N, XS)
and(tt, X) → X
fst(pair(X, Y)) → U21(and(isLNat(X), isLNat(Y)), X)
head(cons(N, XS)) → U31(and(isNatural(N), isLNat(XS)), N)
isLNat(nil) → tt
isLNat(afterNth(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(cons(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(fst(V1)) → isPLNat(V1)
isLNat(natsFrom(V1)) → isNatural(V1)
isLNat(snd(V1)) → isPLNat(V1)
isLNat(tail(V1)) → isLNat(V1)
isLNat(take(V1, V2)) → and(isNatural(V1), isLNat(V2))
isNatural(0) → tt
isNatural(head(V1)) → isLNat(V1)
isNatural(s(V1)) → isNatural(V1)
isNatural(sel(V1, V2)) → and(isNatural(V1), isLNat(V2))
isPLNat(pair(V1, V2)) → and(isLNat(V1), isLNat(V2))
isPLNat(splitAt(V1, V2)) → and(isNatural(V1), isLNat(V2))
natsFrom(N) → U41(isNatural(N), N)
sel(N, XS) → U51(and(isNatural(N), isLNat(XS)), N, XS)
snd(pair(X, Y)) → U61(and(isLNat(X), isLNat(Y)), Y)
splitAt(0, XS) → U71(isLNat(XS), XS)
splitAt(s(N), cons(X, XS)) → U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tail(cons(N, XS)) → U91(and(isNatural(N), isLNat(XS)), XS)
take(N, XS) → U101(and(isNatural(N), isLNat(XS)), N, XS)

Q is empty.

We applied the Incomplete Giesl Middeldorp transformation [11] to transform the context-sensitive TRS to a usual TRS.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
  ↳ Trivial-Transformation

Q restricted rewrite system:
The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.

Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U81(x1, x2, x3, x4)) → U81ACTIVE(mark(x1), x2, x3, x4)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(x1, x2, x3)) → U11ACTIVE(mark(x1), x2, x3)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(fst(x1)) → MARK(x1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
U21ACTIVE(tt, X) → MARK(X)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
MARK(U41(x1, x2)) → MARK(x1)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(head(x1)) → HEADACTIVE(mark(x1))
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
ANDACTIVE(tt, X) → MARK(X)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U101(x1, x2, x3)) → U101ACTIVE(mark(x1), x2, x3)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U71(x1, x2)) → MARK(x1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U41(x1, x2)) → U41ACTIVE(mark(x1), x2)
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U31(x1, x2)) → U31ACTIVE(mark(x1), x2)
U101ACTIVE(tt, N, XS) → MARK(XS)
U11ACTIVE(tt, N, XS) → MARK(XS)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
U101ACTIVE(tt, N, XS) → MARK(N)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → MARK(N)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(take(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(sel(x1, x2)) → MARK(x1)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(afterNth(x1, x2)) → MARK(x2)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U91(x1, x2)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U21(x1, x2)) → MARK(x1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
U61ACTIVE(tt, Y) → MARK(Y)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(afterNth(x1, x2)) → MARK(x1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U31(x1, x2)) → MARK(x1)
MARK(natsFrom(x1)) → MARK(x1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(snd(x1)) → MARK(x1)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
MARK(U101(x1, x2, x3)) → MARK(x1)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
U11ACTIVE(tt, N, XS) → MARK(N)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U81(x1, x2, x3, x4)) → U81ACTIVE(mark(x1), x2, x3, x4)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(x1, x2, x3)) → U11ACTIVE(mark(x1), x2, x3)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(fst(x1)) → MARK(x1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
U21ACTIVE(tt, X) → MARK(X)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
MARK(U41(x1, x2)) → MARK(x1)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(head(x1)) → HEADACTIVE(mark(x1))
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
ANDACTIVE(tt, X) → MARK(X)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U101(x1, x2, x3)) → U101ACTIVE(mark(x1), x2, x3)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U71(x1, x2)) → MARK(x1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U41(x1, x2)) → U41ACTIVE(mark(x1), x2)
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U31(x1, x2)) → U31ACTIVE(mark(x1), x2)
U101ACTIVE(tt, N, XS) → MARK(XS)
U11ACTIVE(tt, N, XS) → MARK(XS)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
U101ACTIVE(tt, N, XS) → MARK(N)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → MARK(N)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(take(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(sel(x1, x2)) → MARK(x1)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(afterNth(x1, x2)) → MARK(x2)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U91(x1, x2)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U21(x1, x2)) → MARK(x1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
U61ACTIVE(tt, Y) → MARK(Y)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(afterNth(x1, x2)) → MARK(x1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U31(x1, x2)) → MARK(x1)
MARK(natsFrom(x1)) → MARK(x1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(snd(x1)) → MARK(x1)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
MARK(U101(x1, x2, x3)) → MARK(x1)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
U11ACTIVE(tt, N, XS) → MARK(N)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(U101(x1, x2, x3)) → U101ACTIVE(mark(x1), x2, x3) at position [0] we obtained the following new rules:

MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(pair(x0, x1), y1, y2)) → U101ACTIVE(pair(mark(x0), mark(x1)), y1, y2)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(U101(s(x0), y1, y2)) → U101ACTIVE(s(mark(x0)), y1, y2)
MARK(U101(cons(x0, x1), y1, y2)) → U101ACTIVE(cons(mark(x0), x1), y1, y2)
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U101(nil, y1, y2)) → U101ACTIVE(nil, y1, y2)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U101(0, y1, y2)) → U101ACTIVE(0, y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U101(cons(x0, x1), y1, y2)) → U101ACTIVE(cons(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U81(x1, x2, x3, x4)) → U81ACTIVE(mark(x1), x2, x3, x4)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U11(x1, x2, x3)) → U11ACTIVE(mark(x1), x2, x3)
MARK(fst(x1)) → MARK(x1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
U21ACTIVE(tt, X) → MARK(X)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(head(x1)) → HEADACTIVE(mark(x1))
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U101(0, y1, y2)) → U101ACTIVE(0, y1, y2)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U71(x1, x2)) → MARK(x1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U41(x1, x2)) → U41ACTIVE(mark(x1), x2)
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(x1, x2)) → U31ACTIVE(mark(x1), x2)
U11ACTIVE(tt, N, XS) → MARK(XS)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U101(s(x0), y1, y2)) → U101ACTIVE(s(mark(x0)), y1, y2)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(take(x1, x2)) → MARK(x1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(splitAt(x1, x2)) → MARK(x2)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(pair(x1, x2)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
U61ACTIVE(tt, Y) → MARK(Y)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U21(x1, x2)) → MARK(x1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(afterNth(x1, x2)) → MARK(x1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U101(pair(x0, x1), y1, y2)) → U101ACTIVE(pair(mark(x0), mark(x1)), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U31(x1, x2)) → MARK(x1)
MARK(natsFrom(x1)) → MARK(x1)
MARK(U101(nil, y1, y2)) → U101ACTIVE(nil, y1, y2)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(snd(x1)) → MARK(x1)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
MARK(U101(x1, x2, x3)) → MARK(x1)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U81(x1, x2, x3, x4)) → U81ACTIVE(mark(x1), x2, x3, x4)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U11(x1, x2, x3)) → U11ACTIVE(mark(x1), x2, x3)
MARK(fst(x1)) → MARK(x1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
U21ACTIVE(tt, X) → MARK(X)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(head(x1)) → HEADACTIVE(mark(x1))
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
ANDACTIVE(tt, X) → MARK(X)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U71(x1, x2)) → MARK(x1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U41(x1, x2)) → U41ACTIVE(mark(x1), x2)
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(x1, x2)) → U31ACTIVE(mark(x1), x2)
U11ACTIVE(tt, N, XS) → MARK(XS)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(take(x1, x2)) → MARK(x1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
MARK(U11(x1, x2, x3)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(pair(x1, x2)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U21(x1, x2)) → MARK(x1)
U61ACTIVE(tt, Y) → MARK(Y)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(afterNth(x1, x2)) → MARK(x1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U31(x1, x2)) → MARK(x1)
MARK(natsFrom(x1)) → MARK(x1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(snd(x1)) → MARK(x1)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
MARK(U101(x1, x2, x3)) → MARK(x1)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(U11(x1, x2, x3)) → U11ACTIVE(mark(x1), x2, x3) at position [0] we obtained the following new rules:

MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
MARK(U11(pair(x0, x1), y1, y2)) → U11ACTIVE(pair(mark(x0), mark(x1)), y1, y2)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U11(nil, y1, y2)) → U11ACTIVE(nil, y1, y2)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U11(s(x0), y1, y2)) → U11ACTIVE(s(mark(x0)), y1, y2)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U11(cons(x0, x1), y1, y2)) → U11ACTIVE(cons(mark(x0), x1), y1, y2)
MARK(U11(0, y1, y2)) → U11ACTIVE(0, y1, y2)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U81(x1, x2, x3, x4)) → U81ACTIVE(mark(x1), x2, x3, x4)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(fst(x1)) → MARK(x1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
U21ACTIVE(tt, X) → MARK(X)
MARK(U11(s(x0), y1, y2)) → U11ACTIVE(s(mark(x0)), y1, y2)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(head(x1)) → HEADACTIVE(mark(x1))
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
ANDACTIVE(tt, X) → MARK(X)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(and(x1, x2)) → MARK(x1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U71(x1, x2)) → MARK(x1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U41(x1, x2)) → U41ACTIVE(mark(x1), x2)
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U31(x1, x2)) → U31ACTIVE(mark(x1), x2)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
U101ACTIVE(tt, N, XS) → MARK(XS)
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(pair(x0, x1), y1, y2)) → U11ACTIVE(pair(mark(x0), mark(x1)), y1, y2)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U11(nil, y1, y2)) → U11ACTIVE(nil, y1, y2)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(take(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(x1, x2, x3)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
MARK(afterNth(x1, x2)) → MARK(x2)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U11(cons(x0, x1), y1, y2)) → U11ACTIVE(cons(mark(x0), x1), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U21(x1, x2)) → MARK(x1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(afterNth(x1, x2)) → MARK(x1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U31(x1, x2)) → MARK(x1)
MARK(natsFrom(x1)) → MARK(x1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(snd(x1)) → MARK(x1)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U11(0, y1, y2)) → U11ACTIVE(0, y1, y2)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U81(x1, x2, x3, x4)) → U81ACTIVE(mark(x1), x2, x3, x4)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(fst(x1)) → MARK(x1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
U21ACTIVE(tt, X) → MARK(X)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(head(x1)) → HEADACTIVE(mark(x1))
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
ANDACTIVE(tt, X) → MARK(X)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(and(x1, x2)) → MARK(x1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U71(x1, x2)) → MARK(x1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U41(x1, x2)) → U41ACTIVE(mark(x1), x2)
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(x1, x2)) → U31ACTIVE(mark(x1), x2)
U11ACTIVE(tt, N, XS) → MARK(XS)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(take(x1, x2)) → MARK(x1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
MARK(U11(x1, x2, x3)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(pair(x1, x2)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U21(x1, x2)) → MARK(x1)
U61ACTIVE(tt, Y) → MARK(Y)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(afterNth(x1, x2)) → MARK(x1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U31(x1, x2)) → MARK(x1)
MARK(natsFrom(x1)) → MARK(x1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(snd(x1)) → MARK(x1)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(U21(x1, x2)) → U21ACTIVE(mark(x1), x2) at position [0] we obtained the following new rules:

MARK(U21(cons(x0, x1), y1)) → U21ACTIVE(cons(mark(x0), x1), y1)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U21(pair(x0, x1), y1)) → U21ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U21(s(x0), y1)) → U21ACTIVE(s(mark(x0)), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U21(0, y1)) → U21ACTIVE(0, y1)
MARK(U21(nil, y1)) → U21ACTIVE(nil, y1)
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U21(cons(x0, x1), y1)) → U21ACTIVE(cons(mark(x0), x1), y1)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U81(x1, x2, x3, x4)) → U81ACTIVE(mark(x1), x2, x3, x4)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
ANDACTIVE(tt, X) → MARK(X)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U21(0, y1)) → U21ACTIVE(0, y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U71(x1, x2)) → MARK(x1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U41(x1, x2)) → U41ACTIVE(mark(x1), x2)
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(x1, x2)) → U31ACTIVE(mark(x1), x2)
U101ACTIVE(tt, N, XS) → MARK(XS)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U21(nil, y1)) → U21ACTIVE(nil, y1)
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(take(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
MARK(U11(x1, x2, x3)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(splitAt(x1, x2)) → MARK(x2)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U61ACTIVE(tt, Y) → MARK(Y)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(afterNth(x1, x2)) → MARK(x1)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U21(s(x0), y1)) → U21ACTIVE(s(mark(x0)), y1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
MARK(U21(pair(x0, x1), y1)) → U21ACTIVE(pair(mark(x0), mark(x1)), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
U21ACTIVE(tt, X) → MARK(X)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(head(x1)) → HEADACTIVE(mark(x1))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U21(x1, x2)) → MARK(x1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(snd(x1)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U81(x1, x2, x3, x4)) → U81ACTIVE(mark(x1), x2, x3, x4)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ANDACTIVE(tt, X) → MARK(X)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U71(x1, x2)) → MARK(x1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U41(x1, x2)) → U41ACTIVE(mark(x1), x2)
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U31(x1, x2)) → U31ACTIVE(mark(x1), x2)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
U101ACTIVE(tt, N, XS) → MARK(XS)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(take(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(afterNth(x1, x2)) → MARK(x1)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
U21ACTIVE(tt, X) → MARK(X)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(head(x1)) → HEADACTIVE(mark(x1))
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U21(x1, x2)) → MARK(x1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(snd(x1)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(U31(x1, x2)) → U31ACTIVE(mark(x1), x2) at position [0] we obtained the following new rules:

MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U31(cons(x0, x1), y1)) → U31ACTIVE(cons(mark(x0), x1), y1)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U31(s(x0), y1)) → U31ACTIVE(s(mark(x0)), y1)
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U31(0, y1)) → U31ACTIVE(0, y1)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U31(nil, y1)) → U31ACTIVE(nil, y1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U31(pair(x0, x1), y1)) → U31ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U81(x1, x2, x3, x4)) → U81ACTIVE(mark(x1), x2, x3, x4)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
ANDACTIVE(tt, X) → MARK(X)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(cons(x0, x1), y1)) → U31ACTIVE(cons(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U71(x1, x2)) → MARK(x1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U41(x1, x2)) → U41ACTIVE(mark(x1), x2)
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
U101ACTIVE(tt, N, XS) → MARK(XS)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, N, XS) → MARK(N)
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(take(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
MARK(U11(x1, x2, x3)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(splitAt(x1, x2)) → MARK(x2)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U31(pair(x0, x1), y1)) → U31ACTIVE(pair(mark(x0), mark(x1)), y1)
U61ACTIVE(tt, Y) → MARK(Y)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(afterNth(x1, x2)) → MARK(x1)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(fst(x1)) → MARK(x1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
U21ACTIVE(tt, X) → MARK(X)
MARK(U31(0, y1)) → U31ACTIVE(0, y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(head(x1)) → HEADACTIVE(mark(x1))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U31(nil, y1)) → U31ACTIVE(nil, y1)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(snd(x1)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U31(s(x0), y1)) → U31ACTIVE(s(mark(x0)), y1)
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U81(x1, x2, x3, x4)) → U81ACTIVE(mark(x1), x2, x3, x4)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ANDACTIVE(tt, X) → MARK(X)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U71(x1, x2)) → MARK(x1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U41(x1, x2)) → U41ACTIVE(mark(x1), x2)
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
U101ACTIVE(tt, N, XS) → MARK(XS)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(take(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(afterNth(x1, x2)) → MARK(x1)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
U21ACTIVE(tt, X) → MARK(X)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(head(x1)) → HEADACTIVE(mark(x1))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(snd(x1)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(U41(x1, x2)) → U41ACTIVE(mark(x1), x2) at position [0] we obtained the following new rules:

MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U41(pair(x0, x1), y1)) → U41ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(nil, y1)) → U41ACTIVE(nil, y1)
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U41(s(x0), y1)) → U41ACTIVE(s(mark(x0)), y1)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(0, y1)) → U41ACTIVE(0, y1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U41(cons(x0, x1), y1)) → U41ACTIVE(cons(mark(x0), x1), y1)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U81(x1, x2, x3, x4)) → U81ACTIVE(mark(x1), x2, x3, x4)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
ANDACTIVE(tt, X) → MARK(X)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U71(x1, x2)) → MARK(x1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, N, XS) → MARK(N)
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
MARK(U11(x1, x2, x3)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(splitAt(x1, x2)) → MARK(x2)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U61ACTIVE(tt, Y) → MARK(Y)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(afterNth(x1, x2)) → MARK(x1)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
MARK(U41(s(x0), y1)) → U41ACTIVE(s(mark(x0)), y1)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U41(nil, y1)) → U41ACTIVE(nil, y1)
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U21ACTIVE(tt, X) → MARK(X)
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(cons(x0, x1), y1)) → U41ACTIVE(cons(mark(x0), x1), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(head(x1)) → HEADACTIVE(mark(x1))
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U21(x1, x2)) → MARK(x1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U41(pair(x0, x1), y1)) → U41ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(snd(x1)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
MARK(U41(0, y1)) → U41ACTIVE(0, y1)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U81(x1, x2, x3, x4)) → U81ACTIVE(mark(x1), x2, x3, x4)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ANDACTIVE(tt, X) → MARK(X)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U71(x1, x2)) → MARK(x1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(take(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(afterNth(x1, x2)) → MARK(x1)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
U21ACTIVE(tt, X) → MARK(X)
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(head(x1)) → HEADACTIVE(mark(x1))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(snd(x1)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(U51(x1, x2, x3)) → U51ACTIVE(mark(x1), x2, x3) at position [0] we obtained the following new rules:

MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U51(s(x0), y1, y2)) → U51ACTIVE(s(mark(x0)), y1, y2)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U51(nil, y1, y2)) → U51ACTIVE(nil, y1, y2)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(cons(x0, x1), y1, y2)) → U51ACTIVE(cons(mark(x0), x1), y1, y2)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U51(pair(x0, x1), y1, y2)) → U51ACTIVE(pair(mark(x0), mark(x1)), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(0, y1, y2)) → U51ACTIVE(0, y1, y2)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U81(x1, x2, x3, x4)) → U81ACTIVE(mark(x1), x2, x3, x4)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
ANDACTIVE(tt, X) → MARK(X)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U71(x1, x2)) → MARK(x1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U51(cons(x0, x1), y1, y2)) → U51ACTIVE(cons(mark(x0), x1), y1, y2)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
U101ACTIVE(tt, N, XS) → MARK(XS)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, N, XS) → MARK(N)
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
MARK(U11(x1, x2, x3)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
MARK(U51(pair(x0, x1), y1, y2)) → U51ACTIVE(pair(mark(x0), mark(x1)), y1, y2)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U21ACTIVE(tt, X) → MARK(X)
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(head(x1)) → HEADACTIVE(mark(x1))
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U51(s(x0), y1, y2)) → U51ACTIVE(s(mark(x0)), y1, y2)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U51(nil, y1, y2)) → U51ACTIVE(nil, y1, y2)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
U41ACTIVE(tt, N) → MARK(N)
MARK(U51(0, y1, y2)) → U51ACTIVE(0, y1, y2)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U81(x1, x2, x3, x4)) → U81ACTIVE(mark(x1), x2, x3, x4)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ANDACTIVE(tt, X) → MARK(X)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U71(x1, x2)) → MARK(x1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(take(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U81ACTIVE(tt, N, X, XS) → MARK(N)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
U21ACTIVE(tt, X) → MARK(X)
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(head(x1)) → HEADACTIVE(mark(x1))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(U61(x1, x2)) → U61ACTIVE(mark(x1), x2) at position [0] we obtained the following new rules:

MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(0, y1)) → U61ACTIVE(0, y1)
MARK(U61(s(x0), y1)) → U61ACTIVE(s(mark(x0)), y1)
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(cons(x0, x1), y1)) → U61ACTIVE(cons(mark(x0), x1), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
MARK(U61(pair(x0, x1), y1)) → U61ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U61(nil, y1)) → U61ACTIVE(nil, y1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U81(x1, x2, x3, x4)) → U81ACTIVE(mark(x1), x2, x3, x4)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U61(pair(x0, x1), y1)) → U61ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U61(s(x0), y1)) → U61ACTIVE(s(mark(x0)), y1)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
ANDACTIVE(tt, X) → MARK(X)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
U101ACTIVE(tt, N, XS) → MARK(XS)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(splitAt(x1, x2)) → MARK(x2)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U61(nil, y1)) → U61ACTIVE(nil, y1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U61ACTIVE(tt, Y) → MARK(Y)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U61(0, y1)) → U61ACTIVE(0, y1)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(head(x1)) → HEADACTIVE(mark(x1))
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U91ACTIVE(tt, XS) → MARK(XS)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U61(cons(x0, x1), y1)) → U61ACTIVE(cons(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U81(x1, x2, x3, x4)) → U81ACTIVE(mark(x1), x2, x3, x4)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ANDACTIVE(tt, X) → MARK(X)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U71(x1, x2)) → MARK(x1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(take(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U81ACTIVE(tt, N, X, XS) → MARK(N)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
U21ACTIVE(tt, X) → MARK(X)
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(head(x1)) → HEADACTIVE(mark(x1))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U91ACTIVE(tt, XS) → MARK(XS)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(U71(x1, x2)) → U71ACTIVE(mark(x1), x2) at position [0] we obtained the following new rules:

MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U71(nil, y1)) → U71ACTIVE(nil, y1)
MARK(U71(cons(x0, x1), y1)) → U71ACTIVE(cons(mark(x0), x1), y1)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(pair(x0, x1), y1)) → U71ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(0, y1)) → U71ACTIVE(0, y1)
MARK(U71(s(x0), y1)) → U71ACTIVE(s(mark(x0)), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U71(nil, y1)) → U71ACTIVE(nil, y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U81(x1, x2, x3, x4)) → U81ACTIVE(mark(x1), x2, x3, x4)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U71(s(x0), y1)) → U71ACTIVE(s(mark(x0)), y1)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
ANDACTIVE(tt, X) → MARK(X)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
U101ACTIVE(tt, N, XS) → MARK(XS)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(splitAt(x1, x2)) → MARK(x2)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U61ACTIVE(tt, Y) → MARK(Y)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
MARK(U71(pair(x0, x1), y1)) → U71ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U71(0, y1)) → U71ACTIVE(0, y1)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(head(x1)) → HEADACTIVE(mark(x1))
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U71(cons(x0, x1), y1)) → U71ACTIVE(cons(mark(x0), x1), y1)
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(snd(x1)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U81(x1, x2, x3, x4)) → U81ACTIVE(mark(x1), x2, x3, x4)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ANDACTIVE(tt, X) → MARK(X)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U71(x1, x2)) → MARK(x1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
U21ACTIVE(tt, X) → MARK(X)
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(head(x1)) → HEADACTIVE(mark(x1))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U91ACTIVE(tt, XS) → MARK(XS)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(snd(x1)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(U81(x1, x2, x3, x4)) → U81ACTIVE(mark(x1), x2, x3, x4) at position [0] we obtained the following new rules:

MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U81(s(x0), y1, y2, y3)) → U81ACTIVE(s(mark(x0)), y1, y2, y3)
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U81(0, y1, y2, y3)) → U81ACTIVE(0, y1, y2, y3)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(U81(pair(x0, x1), y1, y2, y3)) → U81ACTIVE(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
MARK(U81(cons(x0, x1), y1, y2, y3)) → U81ACTIVE(cons(mark(x0), x1), y1, y2, y3)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U81(nil, y1, y2, y3)) → U81ACTIVE(nil, y1, y2, y3)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
ANDACTIVE(tt, X) → MARK(X)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(take(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U81(pair(x0, x1), y1, y2, y3)) → U81ACTIVE(pair(mark(x0), mark(x1)), y1, y2, y3)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(splitAt(x1, x2)) → MARK(x2)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U81(nil, y1, y2, y3)) → U81ACTIVE(nil, y1, y2, y3)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(head(x1)) → HEADACTIVE(mark(x1))
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
MARK(U81(0, y1, y2, y3)) → U81ACTIVE(0, y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U81(s(x0), y1, y2, y3)) → U81ACTIVE(s(mark(x0)), y1, y2, y3)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U81(cons(x0, x1), y1, y2, y3)) → U81ACTIVE(cons(mark(x0), x1), y1, y2, y3)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ANDACTIVE(tt, X) → MARK(X)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(U71(x1, x2)) → MARK(x1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
U21ACTIVE(tt, X) → MARK(X)
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(head(x1)) → HEADACTIVE(mark(x1))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U91ACTIVE(tt, XS) → MARK(XS)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(snd(x1)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(U82(x1, x2)) → U82ACTIVE(mark(x1), x2) at position [0] we obtained the following new rules:

MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(cons(x0, x1), y1)) → U82ACTIVE(cons(mark(x0), x1), y1)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U82(s(x0), y1)) → U82ACTIVE(s(mark(x0)), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(tt, y1)) → U82ACTIVE(tt, y1)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(nil, y1)) → U82ACTIVE(nil, y1)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(0, y1)) → U82ACTIVE(0, y1)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
ANDACTIVE(tt, X) → MARK(X)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(s(x0), y1)) → U82ACTIVE(s(mark(x0)), y1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(tt, y1)) → U82ACTIVE(tt, y1)
MARK(take(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(splitAt(x1, x2)) → MARK(x2)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
MARK(U82(0, y1)) → U82ACTIVE(0, y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(nil, y1)) → U82ACTIVE(nil, y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
MARK(U82(cons(x0, x1), y1)) → U82ACTIVE(cons(mark(x0), x1), y1)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(head(x1)) → HEADACTIVE(mark(x1))
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
MARK(and(x1, x2)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ANDACTIVE(tt, X) → MARK(X)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(U71(x1, x2)) → MARK(x1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U21ACTIVE(tt, X) → MARK(X)
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(head(x1)) → HEADACTIVE(mark(x1))
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U91ACTIVE(tt, XS) → MARK(XS)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
MARK(pair(x1, x2)) → MARK(x2)
U31ACTIVE(tt, N) → MARK(N)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(snd(x1)) → MARK(x1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(U91(x1, x2)) → U91ACTIVE(mark(x1), x2) at position [0] we obtained the following new rules:

MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U91(nil, y1)) → U91ACTIVE(nil, y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(U91(0, y1)) → U91ACTIVE(0, y1)
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U91(s(x0), y1)) → U91ACTIVE(s(mark(x0)), y1)
MARK(U91(cons(x0, x1), y1)) → U91ACTIVE(cons(mark(x0), x1), y1)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U91(pair(x0, x1), y1)) → U91ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U91(0, y1)) → U91ACTIVE(0, y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U91(pair(x0, x1), y1)) → U91ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x1)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U91(cons(x0, x1), y1)) → U91ACTIVE(cons(mark(x0), x1), y1)
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U91(nil, y1)) → U91ACTIVE(nil, y1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(head(x1)) → HEADACTIVE(mark(x1))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U91(s(x0), y1)) → U91ACTIVE(s(mark(x0)), y1)
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x1)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(head(x1)) → HEADACTIVE(mark(x1))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
MARK(and(x1, x2)) → MARK(x1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule U11ACTIVE(tt, N, XS) → SNDACTIVE(splitAtActive(mark(N), mark(XS))) at position [0] we obtained the following new rules:

U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, y0, y1) → SNDACTIVE(splitAt(mark(y0), mark(y1)))
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(snd(x1)) → MARK(x1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, y1) → SNDACTIVE(splitAt(mark(y0), mark(y1)))
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(head(x1)) → HEADACTIVE(mark(x1))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(snd(x1)) → MARK(x1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(sel(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(head(x1)) → HEADACTIVE(mark(x1))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
MARK(and(x1, x2)) → MARK(x1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule U11ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS)) at position [0] we obtained the following new rules:

U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, tt, y1) → SPLITATACTIVE(tt, mark(y1))
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, cons(x0, x1), y1) → SPLITATACTIVE(cons(mark(x0), x1), mark(y1))
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, nil, y1) → SPLITATACTIVE(nil, mark(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SPLITATACTIVE(pair(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U91ACTIVE(tt, XS) → MARK(XS)
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, cons(x0, x1), y1) → SPLITATACTIVE(cons(mark(x0), x1), mark(y1))
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, nil, y1) → SPLITATACTIVE(nil, mark(y1))
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
U11ACTIVE(tt, pair(x0, x1), y1) → SPLITATACTIVE(pair(mark(x0), mark(x1)), mark(y1))
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
U11ACTIVE(tt, tt, y1) → SPLITATACTIVE(tt, mark(y1))
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(head(x1)) → HEADACTIVE(mark(x1))
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(and(x1, x2)) → MARK(x1)
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 4 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(snd(x1)) → MARK(x1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(head(x1)) → HEADACTIVE(mark(x1))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(and(x1, x2)) → ANDACTIVE(mark(x1), x2) at position [0] we obtained the following new rules:

MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(s(x0), y1)) → ANDACTIVE(s(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(and(nil, y1)) → ANDACTIVE(nil, y1)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(pair(x0, x1), y1)) → ANDACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(cons(x0, x1), y1)) → ANDACTIVE(cons(mark(x0), x1), y1)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(and(0, y1)) → ANDACTIVE(0, y1)
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(nil, y1)) → ANDACTIVE(nil, y1)
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
MARK(and(s(x0), y1)) → ANDACTIVE(s(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(and(pair(x0, x1), y1)) → ANDACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(cons(x0, x1), y1)) → ANDACTIVE(cons(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U91ACTIVE(tt, XS) → MARK(XS)
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → MARK(XS)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(and(0, y1)) → ANDACTIVE(0, y1)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(head(x1)) → HEADACTIVE(mark(x1))
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(and(x1, x2)) → MARK(x1)
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(x1)) → FSTACTIVE(mark(x1))
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(snd(x1)) → MARK(x1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(head(x1)) → HEADACTIVE(mark(x1))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(fst(x1)) → FSTACTIVE(mark(x1)) at position [0] we obtained the following new rules:

MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(fst(0)) → FSTACTIVE(0)
MARK(fst(s(x0))) → FSTACTIVE(s(mark(x0)))
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(fst(cons(x0, x1))) → FSTACTIVE(cons(mark(x0), x1))
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(fst(nil)) → FSTACTIVE(nil)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(fst(tt)) → FSTACTIVE(tt)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(fst(cons(x0, x1))) → FSTACTIVE(cons(mark(x0), x1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
MARK(fst(s(x0))) → FSTACTIVE(s(mark(x0)))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U91ACTIVE(tt, XS) → MARK(XS)
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → MARK(XS)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(fst(nil)) → FSTACTIVE(nil)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(head(x1)) → HEADACTIVE(mark(x1))
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(and(x1, x2)) → MARK(x1)
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(fst(0)) → FSTACTIVE(0)
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
MARK(fst(tt)) → FSTACTIVE(tt)
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(snd(x1)) → MARK(x1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(head(x1)) → HEADACTIVE(mark(x1))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(and(x1, x2)) → MARK(x1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(head(x1)) → HEADACTIVE(mark(x1)) at position [0] we obtained the following new rules:

MARK(head(0)) → HEADACTIVE(0)
MARK(head(tt)) → HEADACTIVE(tt)
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(head(nil)) → HEADACTIVE(nil)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
MARK(head(pair(x0, x1))) → HEADACTIVE(pair(mark(x0), mark(x1)))
MARK(head(s(x0))) → HEADACTIVE(s(mark(x0)))
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(head(tt)) → HEADACTIVE(tt)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(head(nil)) → HEADACTIVE(nil)
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
MARK(head(s(x0))) → HEADACTIVE(s(mark(x0)))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U91ACTIVE(tt, XS) → MARK(XS)
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(head(0)) → HEADACTIVE(0)
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → MARK(XS)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(head(pair(x0, x1))) → HEADACTIVE(pair(mark(x0), mark(x1)))
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(and(x1, x2)) → MARK(x1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(snd(x1)) → MARK(x1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(and(x1, x2)) → MARK(x1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule ISLNATACTIVE(afterNth(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2)) at position [0] we obtained the following new rules:

ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
ISLNATACTIVE(afterNth(x0, y1)) → ANDACTIVE(isNatural(x0), isLNat(y1))
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U91ACTIVE(tt, XS) → MARK(XS)
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → MARK(XS)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
ISLNATACTIVE(afterNth(x0, y1)) → ANDACTIVE(isNatural(x0), isLNat(y1))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(and(x1, x2)) → MARK(x1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(snd(x1)) → MARK(x1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(and(x1, x2)) → MARK(x1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule ISLNATACTIVE(cons(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2)) at position [0] we obtained the following new rules:

ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
ISLNATACTIVE(cons(x0, y1)) → ANDACTIVE(isNatural(x0), isLNat(y1))
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(cons(x0, y1)) → ANDACTIVE(isNatural(x0), isLNat(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U91ACTIVE(tt, XS) → MARK(XS)
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → MARK(XS)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(and(x1, x2)) → MARK(x1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(snd(x1)) → MARK(x1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(and(x1, x2)) → MARK(x1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule ISNATURALACTIVE(sel(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2)) at position [0] we obtained the following new rules:

ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISNATURALACTIVE(sel(x0, y1)) → ANDACTIVE(isNatural(x0), isLNat(y1))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U91ACTIVE(tt, XS) → MARK(XS)
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → MARK(XS)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
ISNATURALACTIVE(sel(x0, y1)) → ANDACTIVE(isNatural(x0), isLNat(y1))
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(and(x1, x2)) → MARK(x1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(snd(x1)) → MARK(x1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(and(x1, x2)) → MARK(x1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule ISPLNATACTIVE(pair(V1, V2)) → ANDACTIVE(isLNatActive(V1), isLNat(V2)) at position [0] we obtained the following new rules:

ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISPLNATACTIVE(pair(x0, y1)) → ANDACTIVE(isLNat(x0), isLNat(y1))
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
ISPLNATACTIVE(pair(x0, y1)) → ANDACTIVE(isLNat(x0), isLNat(y1))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U91ACTIVE(tt, XS) → MARK(XS)
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → MARK(XS)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(and(x1, x2)) → MARK(x1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, N, XS) → MARK(XS)
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(snd(x1)) → MARK(x1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule ISPLNATACTIVE(splitAt(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2)) at position [0] we obtained the following new rules:

ISPLNATACTIVE(splitAt(x0, y1)) → ANDACTIVE(isNatural(x0), isLNat(y1))
ISPLNATACTIVE(splitAt(0, y1)) → ANDACTIVE(tt, isLNat(y1))
ISPLNATACTIVE(splitAt(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISPLNATACTIVE(splitAt(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
ISPLNATACTIVE(splitAt(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
ISPLNATACTIVE(splitAt(x0, y1)) → ANDACTIVE(isNatural(x0), isLNat(y1))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
ISPLNATACTIVE(splitAt(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U91ACTIVE(tt, XS) → MARK(XS)
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → MARK(XS)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
ISPLNATACTIVE(splitAt(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
ISPLNATACTIVE(splitAt(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(and(x1, x2)) → MARK(x1)
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
ISPLNATACTIVE(splitAt(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2))
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
ISPLNATACTIVE(splitAt(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, N, XS) → MARK(XS)
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(snd(x1)) → MARK(x1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
ISPLNATACTIVE(splitAt(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
ISPLNATACTIVE(splitAt(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
ISPLNATACTIVE(splitAt(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule ISLNATACTIVE(take(V1, V2)) → ANDACTIVE(isNaturalActive(V1), isLNat(V2)) at position [0] we obtained the following new rules:

ISLNATACTIVE(take(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
ISLNATACTIVE(take(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(take(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
ISLNATACTIVE(take(x0, y1)) → ANDACTIVE(isNatural(x0), isLNat(y1))
ISLNATACTIVE(take(0, y1)) → ANDACTIVE(tt, isLNat(y1))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
ISLNATACTIVE(take(x0, y1)) → ANDACTIVE(isNatural(x0), isLNat(y1))
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(take(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
ISPLNATACTIVE(splitAt(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U91ACTIVE(tt, XS) → MARK(XS)
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → MARK(XS)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(take(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
ISLNATACTIVE(take(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
ISPLNATACTIVE(splitAt(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
ISPLNATACTIVE(splitAt(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(and(x1, x2)) → MARK(x1)
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
ISLNATACTIVE(take(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
ISPLNATACTIVE(splitAt(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS)))
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
ISLNATACTIVE(take(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
ISPLNATACTIVE(splitAt(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, N, XS) → MARK(XS)
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(snd(x1)) → MARK(x1)
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(take(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
ISLNATACTIVE(take(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
ISPLNATACTIVE(splitAt(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
ISPLNATACTIVE(splitAt(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(take(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U31ACTIVE(tt, N) → MARK(N)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
ISPLNATACTIVE(splitAt(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule U51ACTIVE(tt, N, XS) → HEADACTIVE(afterNthActive(mark(N), mark(XS))) at position [0] we obtained the following new rules:

U51ACTIVE(tt, isNatural(x0), y1) → HEADACTIVE(afterNthActive(isNaturalActive(x0), mark(y1)))
U51ACTIVE(tt, U82(x0, x1), y1) → HEADACTIVE(afterNthActive(U82Active(mark(x0), x1), mark(y1)))
U51ACTIVE(tt, isLNat(x0), y1) → HEADACTIVE(afterNthActive(isLNatActive(x0), mark(y1)))
U51ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → HEADACTIVE(afterNthActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U51ACTIVE(tt, fst(x0), y1) → HEADACTIVE(afterNthActive(fstActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, snd(x0), y1) → HEADACTIVE(afterNthActive(sndActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, y0, U61(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U61Active(mark(x0), x1)))
U51ACTIVE(tt, y0, sel(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), selActive(mark(x0), mark(x1))))
U51ACTIVE(tt, natsFrom(x0), y1) → HEADACTIVE(afterNthActive(natsFromActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, y0, isLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isLNatActive(x0)))
U51ACTIVE(tt, U81(x0, x1, x2, x3), y1) → HEADACTIVE(afterNthActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
U51ACTIVE(tt, U41(x0, x1), y1) → HEADACTIVE(afterNthActive(U41Active(mark(x0), x1), mark(y1)))
U51ACTIVE(tt, y0, s(x0)) → HEADACTIVE(afterNthActive(mark(y0), s(mark(x0))))
U51ACTIVE(tt, take(x0, x1), y1) → HEADACTIVE(afterNthActive(takeActive(mark(x0), mark(x1)), mark(y1)))
U51ACTIVE(tt, y0, 0) → HEADACTIVE(afterNthActive(mark(y0), 0))
U51ACTIVE(tt, 0, y1) → HEADACTIVE(afterNthActive(0, mark(y1)))
U51ACTIVE(tt, U31(x0, x1), y1) → HEADACTIVE(afterNthActive(U31Active(mark(x0), x1), mark(y1)))
U51ACTIVE(tt, y0, nil) → HEADACTIVE(afterNthActive(mark(y0), nil))
U51ACTIVE(tt, nil, y1) → HEADACTIVE(afterNthActive(nil, mark(y1)))
U51ACTIVE(tt, y0, take(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), takeActive(mark(x0), mark(x1))))
U51ACTIVE(tt, y0, cons(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), cons(mark(x0), x1)))
U51ACTIVE(tt, y0, splitAt(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
U51ACTIVE(tt, U51(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U51Active(mark(x0), x1, x2), mark(y1)))
U51ACTIVE(tt, y0, U82(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U82Active(mark(x0), x1)))
U51ACTIVE(tt, y0, y1) → HEADACTIVE(afterNth(mark(y0), mark(y1)))
U51ACTIVE(tt, y0, tt) → HEADACTIVE(afterNthActive(mark(y0), tt))
U51ACTIVE(tt, tt, y1) → HEADACTIVE(afterNthActive(tt, mark(y1)))
U51ACTIVE(tt, y0, natsFrom(x0)) → HEADACTIVE(afterNthActive(mark(y0), natsFromActive(mark(x0))))
U51ACTIVE(tt, splitAt(x0, x1), y1) → HEADACTIVE(afterNthActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
U51ACTIVE(tt, y0, isNatural(x0)) → HEADACTIVE(afterNthActive(mark(y0), isNaturalActive(x0)))
U51ACTIVE(tt, y0, afterNth(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
U51ACTIVE(tt, y0, pair(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), pair(mark(x0), mark(x1))))
U51ACTIVE(tt, y0, U101(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U101Active(mark(x0), x1, x2)))
U51ACTIVE(tt, y0, and(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), andActive(mark(x0), x1)))
U51ACTIVE(tt, U101(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U101Active(mark(x0), x1, x2), mark(y1)))
U51ACTIVE(tt, head(x0), y1) → HEADACTIVE(afterNthActive(headActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, U11(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U11Active(mark(x0), x1, x2), mark(y1)))
U51ACTIVE(tt, cons(x0, x1), y1) → HEADACTIVE(afterNthActive(cons(mark(x0), x1), mark(y1)))
U51ACTIVE(tt, and(x0, x1), y1) → HEADACTIVE(afterNthActive(andActive(mark(x0), x1), mark(y1)))
U51ACTIVE(tt, y0, isPLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isPLNatActive(x0)))
U51ACTIVE(tt, y0, tail(x0)) → HEADACTIVE(afterNthActive(mark(y0), tailActive(mark(x0))))
U51ACTIVE(tt, y0, U11(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U11Active(mark(x0), x1, x2)))
U51ACTIVE(tt, tail(x0), y1) → HEADACTIVE(afterNthActive(tailActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, afterNth(x0, x1), y1) → HEADACTIVE(afterNthActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U51ACTIVE(tt, U61(x0, x1), y1) → HEADACTIVE(afterNthActive(U61Active(mark(x0), x1), mark(y1)))
U51ACTIVE(tt, y0, head(x0)) → HEADACTIVE(afterNthActive(mark(y0), headActive(mark(x0))))
U51ACTIVE(tt, isPLNat(x0), y1) → HEADACTIVE(afterNthActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, y0, U71(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U71Active(mark(x0), x1)))
U51ACTIVE(tt, pair(x0, x1), y1) → HEADACTIVE(afterNthActive(pair(mark(x0), mark(x1)), mark(y1)))
U51ACTIVE(tt, y0, fst(x0)) → HEADACTIVE(afterNthActive(mark(y0), fstActive(mark(x0))))
U51ACTIVE(tt, U71(x0, x1), y1) → HEADACTIVE(afterNthActive(U71Active(mark(x0), x1), mark(y1)))
U51ACTIVE(tt, y0, U91(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U91Active(mark(x0), x1)))
U51ACTIVE(tt, y0, y1) → HEADACTIVE(U11Active(andActive(isNaturalActive(mark(y0)), isLNat(mark(y1))), mark(y0), mark(y1)))
U51ACTIVE(tt, y0, U41(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, y0, U21(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U21Active(mark(x0), x1)))
U51ACTIVE(tt, y0, U31(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U31Active(mark(x0), x1)))
U51ACTIVE(tt, sel(x0, x1), y1) → HEADACTIVE(afterNthActive(selActive(mark(x0), mark(x1)), mark(y1)))
U51ACTIVE(tt, y0, snd(x0)) → HEADACTIVE(afterNthActive(mark(y0), sndActive(mark(x0))))
U51ACTIVE(tt, U91(x0, x1), y1) → HEADACTIVE(afterNthActive(U91Active(mark(x0), x1), mark(y1)))
U51ACTIVE(tt, s(x0), y1) → HEADACTIVE(afterNthActive(s(mark(x0)), mark(y1)))
U51ACTIVE(tt, y0, U51(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U51Active(mark(x0), x1, x2)))
U51ACTIVE(tt, U21(x0, x1), y1) → HEADACTIVE(afterNthActive(U21Active(mark(x0), x1), mark(y1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U51ACTIVE(tt, U51(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U51ACTIVE(tt, y0, U101(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U101Active(mark(x0), x1, x2)))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U51ACTIVE(tt, y0, head(x0)) → HEADACTIVE(afterNthActive(mark(y0), headActive(mark(x0))))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
U51ACTIVE(tt, y0, U91(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U91Active(mark(x0), x1)))
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
U51ACTIVE(tt, s(x0), y1) → HEADACTIVE(afterNthActive(s(mark(x0)), mark(y1)))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U51ACTIVE(tt, U82(x0, x1), y1) → HEADACTIVE(afterNthActive(U82Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
U51ACTIVE(tt, 0, y1) → HEADACTIVE(afterNthActive(0, mark(y1)))
U51ACTIVE(tt, y0, 0) → HEADACTIVE(afterNthActive(mark(y0), 0))
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
U51ACTIVE(tt, tail(x0), y1) → HEADACTIVE(afterNthActive(tailActive(mark(x0)), mark(y1)))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, snd(x0)) → HEADACTIVE(afterNthActive(mark(y0), sndActive(mark(x0))))
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, snd(x0), y1) → HEADACTIVE(afterNthActive(sndActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, natsFrom(x0), y1) → HEADACTIVE(afterNthActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
U51ACTIVE(tt, take(x0, x1), y1) → HEADACTIVE(afterNthActive(takeActive(mark(x0), mark(x1)), mark(y1)))
U51ACTIVE(tt, y0, s(x0)) → HEADACTIVE(afterNthActive(mark(y0), s(mark(x0))))
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
U51ACTIVE(tt, nil, y1) → HEADACTIVE(afterNthActive(nil, mark(y1)))
U51ACTIVE(tt, y0, nil) → HEADACTIVE(afterNthActive(mark(y0), nil))
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U51ACTIVE(tt, y0, and(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), andActive(mark(x0), x1)))
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
U51ACTIVE(tt, U101(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
U51ACTIVE(tt, y0, tail(x0)) → HEADACTIVE(afterNthActive(mark(y0), tailActive(mark(x0))))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, afterNth(x0, x1), y1) → HEADACTIVE(afterNthActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(take(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U51ACTIVE(tt, y0, U21(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U21Active(mark(x0), x1)))
U51ACTIVE(tt, U21(x0, x1), y1) → HEADACTIVE(afterNthActive(U21Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
ISPLNATACTIVE(splitAt(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U51ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → HEADACTIVE(afterNthActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U91ACTIVE(tt, XS) → MARK(XS)
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
U51ACTIVE(tt, y0, splitAt(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
U51ACTIVE(tt, y0, U82(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
U51ACTIVE(tt, y0, natsFrom(x0)) → HEADACTIVE(afterNthActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, y0, isNatural(x0)) → HEADACTIVE(afterNthActive(mark(y0), isNaturalActive(x0)))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → MARK(XS)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
U51ACTIVE(tt, y0, pair(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
U51ACTIVE(tt, and(x0, x1), y1) → HEADACTIVE(afterNthActive(andActive(mark(x0), x1), mark(y1)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
U51ACTIVE(tt, isPLNat(x0), y1) → HEADACTIVE(afterNthActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, U71(x0, x1), y1) → HEADACTIVE(afterNthActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, y1) → HEADACTIVE(U11Active(andActive(isNaturalActive(mark(y0)), isLNat(mark(y1))), mark(y0), mark(y1)))
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(take(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
U51ACTIVE(tt, isLNat(x0), y1) → HEADACTIVE(afterNthActive(isLNatActive(x0), mark(y1)))
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
U51ACTIVE(tt, fst(x0), y1) → HEADACTIVE(afterNthActive(fstActive(mark(x0)), mark(y1)))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
ISLNATACTIVE(take(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, y0, sel(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
U51ACTIVE(tt, U81(x0, x1, x2, x3), y1) → HEADACTIVE(afterNthActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
ISPLNATACTIVE(splitAt(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
U51ACTIVE(tt, y0, take(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, U11(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U11Active(mark(x0), x1, x2), mark(y1)))
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
U51ACTIVE(tt, U61(x0, x1), y1) → HEADACTIVE(afterNthActive(U61Active(mark(x0), x1), mark(y1)))
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U31(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
U51ACTIVE(tt, isNatural(x0), y1) → HEADACTIVE(afterNthActive(isNaturalActive(x0), mark(y1)))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
U51ACTIVE(tt, U31(x0, x1), y1) → HEADACTIVE(afterNthActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U51ACTIVE(tt, y0, afterNth(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, y0, fst(x0)) → HEADACTIVE(afterNthActive(mark(y0), fstActive(mark(x0))))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
ISPLNATACTIVE(splitAt(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U51ACTIVE(tt, tt, y1) → HEADACTIVE(afterNthActive(tt, mark(y1)))
U51ACTIVE(tt, y0, tt) → HEADACTIVE(afterNthActive(mark(y0), tt))
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(and(x1, x2)) → MARK(x1)
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U51ACTIVE(tt, y0, U41(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U41Active(mark(x0), x1)))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, y0, U51(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U51Active(mark(x0), x1, x2)))
U51ACTIVE(tt, U91(x0, x1), y1) → HEADACTIVE(afterNthActive(U91Active(mark(x0), x1), mark(y1)))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U61(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U61Active(mark(x0), x1)))
ISLNATACTIVE(take(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, isLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isLNatActive(x0)))
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
U51ACTIVE(tt, U41(x0, x1), y1) → HEADACTIVE(afterNthActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U51ACTIVE(tt, y0, cons(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
U51ACTIVE(tt, y0, y1) → HEADACTIVE(afterNth(mark(y0), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
U51ACTIVE(tt, splitAt(x0, x1), y1) → HEADACTIVE(afterNthActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
U51ACTIVE(tt, head(x0), y1) → HEADACTIVE(afterNthActive(headActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, cons(x0, x1), y1) → HEADACTIVE(afterNthActive(cons(mark(x0), x1), mark(y1)))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U51ACTIVE(tt, y0, isPLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isPLNatActive(x0)))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U51ACTIVE(tt, y0, U11(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U11Active(mark(x0), x1, x2)))
U31ACTIVE(tt, N) → MARK(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, y0, U71(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U71Active(mark(x0), x1)))
U51ACTIVE(tt, pair(x0, x1), y1) → HEADACTIVE(afterNthActive(pair(mark(x0), mark(x1)), mark(y1)))
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, sel(x0, x1), y1) → HEADACTIVE(afterNthActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
ISPLNATACTIVE(splitAt(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
U51ACTIVE(tt, U51(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U51ACTIVE(tt, y0, U101(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U101Active(mark(x0), x1, x2)))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U51ACTIVE(tt, y0, head(x0)) → HEADACTIVE(afterNthActive(mark(y0), headActive(mark(x0))))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
U51ACTIVE(tt, y0, U91(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U91Active(mark(x0), x1)))
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
U51ACTIVE(tt, s(x0), y1) → HEADACTIVE(afterNthActive(s(mark(x0)), mark(y1)))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U51ACTIVE(tt, U82(x0, x1), y1) → HEADACTIVE(afterNthActive(U82Active(mark(x0), x1), mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
U51ACTIVE(tt, y0, 0) → HEADACTIVE(afterNthActive(mark(y0), 0))
U51ACTIVE(tt, 0, y1) → HEADACTIVE(afterNthActive(0, mark(y1)))
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U51ACTIVE(tt, tail(x0), y1) → HEADACTIVE(afterNthActive(tailActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, snd(x0)) → HEADACTIVE(afterNthActive(mark(y0), sndActive(mark(x0))))
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, snd(x0), y1) → HEADACTIVE(afterNthActive(sndActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, natsFrom(x0), y1) → HEADACTIVE(afterNthActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, y0, s(x0)) → HEADACTIVE(afterNthActive(mark(y0), s(mark(x0))))
U51ACTIVE(tt, take(x0, x1), y1) → HEADACTIVE(afterNthActive(takeActive(mark(x0), mark(x1)), mark(y1)))
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, y0, nil) → HEADACTIVE(afterNthActive(mark(y0), nil))
U51ACTIVE(tt, nil, y1) → HEADACTIVE(afterNthActive(nil, mark(y1)))
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
U51ACTIVE(tt, y0, and(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), andActive(mark(x0), x1)))
U51ACTIVE(tt, U101(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
U51ACTIVE(tt, y0, tail(x0)) → HEADACTIVE(afterNthActive(mark(y0), tailActive(mark(x0))))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, afterNth(x0, x1), y1) → HEADACTIVE(afterNthActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
ISLNATACTIVE(take(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U51ACTIVE(tt, y0, U21(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U21Active(mark(x0), x1)))
U51ACTIVE(tt, U21(x0, x1), y1) → HEADACTIVE(afterNthActive(U21Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
ISPLNATACTIVE(splitAt(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → HEADACTIVE(afterNthActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
U51ACTIVE(tt, y0, splitAt(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U82(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U21(x1, x2)) → MARK(x1)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, y0, natsFrom(x0)) → HEADACTIVE(afterNthActive(mark(y0), natsFromActive(mark(x0))))
U51ACTIVE(tt, y0, isNatural(x0)) → HEADACTIVE(afterNthActive(mark(y0), isNaturalActive(x0)))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, N, XS) → MARK(XS)
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
U51ACTIVE(tt, y0, pair(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U51ACTIVE(tt, and(x0, x1), y1) → HEADACTIVE(afterNthActive(andActive(mark(x0), x1), mark(y1)))
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(snd(x1)) → MARK(x1)
U51ACTIVE(tt, isPLNat(x0), y1) → HEADACTIVE(afterNthActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, U71(x0, x1), y1) → HEADACTIVE(afterNthActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, y1) → HEADACTIVE(U11Active(andActive(isNaturalActive(mark(y0)), isLNat(mark(y1))), mark(y0), mark(y1)))
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(take(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
U51ACTIVE(tt, isLNat(x0), y1) → HEADACTIVE(afterNthActive(isLNatActive(x0), mark(y1)))
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U51ACTIVE(tt, fst(x0), y1) → HEADACTIVE(afterNthActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(take(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, y0, sel(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
ISPLNATACTIVE(splitAt(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U51ACTIVE(tt, U81(x0, x1, x2, x3), y1) → HEADACTIVE(afterNthActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, take(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, U11(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U11Active(mark(x0), x1, x2), mark(y1)))
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
U51ACTIVE(tt, U61(x0, x1), y1) → HEADACTIVE(afterNthActive(U61Active(mark(x0), x1), mark(y1)))
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U31(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
U51ACTIVE(tt, isNatural(x0), y1) → HEADACTIVE(afterNthActive(isNaturalActive(x0), mark(y1)))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U51ACTIVE(tt, U31(x0, x1), y1) → HEADACTIVE(afterNthActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U51ACTIVE(tt, y0, afterNth(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, y0, fst(x0)) → HEADACTIVE(afterNthActive(mark(y0), fstActive(mark(x0))))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
ISPLNATACTIVE(splitAt(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
U51ACTIVE(tt, y0, tt) → HEADACTIVE(afterNthActive(mark(y0), tt))
U51ACTIVE(tt, tt, y1) → HEADACTIVE(afterNthActive(tt, mark(y1)))
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U51ACTIVE(tt, y0, U41(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U41Active(mark(x0), x1)))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U51(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U51Active(mark(x0), x1, x2)))
U51ACTIVE(tt, U91(x0, x1), y1) → HEADACTIVE(afterNthActive(U91Active(mark(x0), x1), mark(y1)))
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(take(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U51ACTIVE(tt, y0, U61(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, y0, isLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isLNatActive(x0)))
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
U51ACTIVE(tt, U41(x0, x1), y1) → HEADACTIVE(afterNthActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, cons(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
U51ACTIVE(tt, splitAt(x0, x1), y1) → HEADACTIVE(afterNthActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, head(x0), y1) → HEADACTIVE(afterNthActive(headActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, cons(x0, x1), y1) → HEADACTIVE(afterNthActive(cons(mark(x0), x1), mark(y1)))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U51ACTIVE(tt, y0, isPLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isPLNatActive(x0)))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U51ACTIVE(tt, y0, U11(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U11Active(mark(x0), x1, x2)))
U31ACTIVE(tt, N) → MARK(N)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, y0, U71(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U71Active(mark(x0), x1)))
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U51ACTIVE(tt, pair(x0, x1), y1) → HEADACTIVE(afterNthActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, sel(x0, x1), y1) → HEADACTIVE(afterNthActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
ISPLNATACTIVE(splitAt(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule AFTERNTHACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS)) at position [0] we obtained the following new rules:

AFTERNTHACTIVE(head(x0), y1) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
AFTERNTHACTIVE(s(x0), y1) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
AFTERNTHACTIVE(x0, y1) → ANDACTIVE(isNatural(x0), isLNat(y1))
AFTERNTHACTIVE(sel(x0, x1), y1) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
AFTERNTHACTIVE(0, y1) → ANDACTIVE(tt, isLNat(y1))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U51ACTIVE(tt, U51(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
U51ACTIVE(tt, y0, U101(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U101Active(mark(x0), x1, x2)))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U51ACTIVE(tt, y0, head(x0)) → HEADACTIVE(afterNthActive(mark(y0), headActive(mark(x0))))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
U51ACTIVE(tt, y0, U91(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U91Active(mark(x0), x1)))
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
U51ACTIVE(tt, s(x0), y1) → HEADACTIVE(afterNthActive(s(mark(x0)), mark(y1)))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U51ACTIVE(tt, U82(x0, x1), y1) → HEADACTIVE(afterNthActive(U82Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
U51ACTIVE(tt, 0, y1) → HEADACTIVE(afterNthActive(0, mark(y1)))
U51ACTIVE(tt, y0, 0) → HEADACTIVE(afterNthActive(mark(y0), 0))
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
U51ACTIVE(tt, tail(x0), y1) → HEADACTIVE(afterNthActive(tailActive(mark(x0)), mark(y1)))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, snd(x0)) → HEADACTIVE(afterNthActive(mark(y0), sndActive(mark(x0))))
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, snd(x0), y1) → HEADACTIVE(afterNthActive(sndActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, natsFrom(x0), y1) → HEADACTIVE(afterNthActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
U51ACTIVE(tt, take(x0, x1), y1) → HEADACTIVE(afterNthActive(takeActive(mark(x0), mark(x1)), mark(y1)))
U51ACTIVE(tt, y0, s(x0)) → HEADACTIVE(afterNthActive(mark(y0), s(mark(x0))))
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
U51ACTIVE(tt, nil, y1) → HEADACTIVE(afterNthActive(nil, mark(y1)))
U51ACTIVE(tt, y0, nil) → HEADACTIVE(afterNthActive(mark(y0), nil))
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U51ACTIVE(tt, y0, and(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), andActive(mark(x0), x1)))
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
U51ACTIVE(tt, U101(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
U51ACTIVE(tt, y0, tail(x0)) → HEADACTIVE(afterNthActive(mark(y0), tailActive(mark(x0))))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, afterNth(x0, x1), y1) → HEADACTIVE(afterNthActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(take(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U51ACTIVE(tt, y0, U21(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U21Active(mark(x0), x1)))
U51ACTIVE(tt, U21(x0, x1), y1) → HEADACTIVE(afterNthActive(U21Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
ISPLNATACTIVE(splitAt(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U51ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → HEADACTIVE(afterNthActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U91ACTIVE(tt, XS) → MARK(XS)
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
U51ACTIVE(tt, y0, splitAt(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
U51ACTIVE(tt, y0, U82(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
U51ACTIVE(tt, y0, natsFrom(x0)) → HEADACTIVE(afterNthActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, y0, isNatural(x0)) → HEADACTIVE(afterNthActive(mark(y0), isNaturalActive(x0)))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → MARK(XS)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
U51ACTIVE(tt, y0, pair(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
U51ACTIVE(tt, and(x0, x1), y1) → HEADACTIVE(afterNthActive(andActive(mark(x0), x1), mark(y1)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
U51ACTIVE(tt, isPLNat(x0), y1) → HEADACTIVE(afterNthActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, U71(x0, x1), y1) → HEADACTIVE(afterNthActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, y1) → HEADACTIVE(U11Active(andActive(isNaturalActive(mark(y0)), isLNat(mark(y1))), mark(y0), mark(y1)))
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(take(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
U51ACTIVE(tt, isLNat(x0), y1) → HEADACTIVE(afterNthActive(isLNatActive(x0), mark(y1)))
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
U51ACTIVE(tt, fst(x0), y1) → HEADACTIVE(afterNthActive(fstActive(mark(x0)), mark(y1)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
ISLNATACTIVE(take(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, y0, sel(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
U51ACTIVE(tt, U81(x0, x1, x2, x3), y1) → HEADACTIVE(afterNthActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
ISPLNATACTIVE(splitAt(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
U51ACTIVE(tt, y0, take(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, U11(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U11Active(mark(x0), x1, x2), mark(y1)))
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U51ACTIVE(tt, U61(x0, x1), y1) → HEADACTIVE(afterNthActive(U61Active(mark(x0), x1), mark(y1)))
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U31(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
U51ACTIVE(tt, isNatural(x0), y1) → HEADACTIVE(afterNthActive(isNaturalActive(x0), mark(y1)))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
U51ACTIVE(tt, U31(x0, x1), y1) → HEADACTIVE(afterNthActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U51ACTIVE(tt, y0, afterNth(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, y0, fst(x0)) → HEADACTIVE(afterNthActive(mark(y0), fstActive(mark(x0))))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
ISPLNATACTIVE(splitAt(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
AFTERNTHACTIVE(head(x0), y1) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U51ACTIVE(tt, tt, y1) → HEADACTIVE(afterNthActive(tt, mark(y1)))
U51ACTIVE(tt, y0, tt) → HEADACTIVE(afterNthActive(mark(y0), tt))
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
AFTERNTHACTIVE(0, y1) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(and(x1, x2)) → MARK(x1)
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U51ACTIVE(tt, y0, U41(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U41Active(mark(x0), x1)))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
AFTERNTHACTIVE(s(x0), y1) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(snd(x1)) → SNDACTIVE(mark(x1))
U51ACTIVE(tt, U91(x0, x1), y1) → HEADACTIVE(afterNthActive(U91Active(mark(x0), x1), mark(y1)))
U51ACTIVE(tt, y0, U51(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U61(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U61Active(mark(x0), x1)))
ISLNATACTIVE(take(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
AFTERNTHACTIVE(sel(x0, x1), y1) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U51ACTIVE(tt, y0, isLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isLNatActive(x0)))
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
U51ACTIVE(tt, U41(x0, x1), y1) → HEADACTIVE(afterNthActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U51ACTIVE(tt, y0, cons(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
U51ACTIVE(tt, splitAt(x0, x1), y1) → HEADACTIVE(afterNthActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
AFTERNTHACTIVE(x0, y1) → ANDACTIVE(isNatural(x0), isLNat(y1))
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
U51ACTIVE(tt, head(x0), y1) → HEADACTIVE(afterNthActive(headActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, cons(x0, x1), y1) → HEADACTIVE(afterNthActive(cons(mark(x0), x1), mark(y1)))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U51ACTIVE(tt, y0, isPLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isPLNatActive(x0)))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U51ACTIVE(tt, y0, U11(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U11Active(mark(x0), x1, x2)))
U31ACTIVE(tt, N) → MARK(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, y0, U71(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U71Active(mark(x0), x1)))
U51ACTIVE(tt, pair(x0, x1), y1) → HEADACTIVE(afterNthActive(pair(mark(x0), mark(x1)), mark(y1)))
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, sel(x0, x1), y1) → HEADACTIVE(afterNthActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
ISPLNATACTIVE(splitAt(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
U51ACTIVE(tt, U51(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U51ACTIVE(tt, y0, U101(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U101Active(mark(x0), x1, x2)))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U51ACTIVE(tt, y0, head(x0)) → HEADACTIVE(afterNthActive(mark(y0), headActive(mark(x0))))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
U51ACTIVE(tt, y0, U91(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U91Active(mark(x0), x1)))
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
U51ACTIVE(tt, s(x0), y1) → HEADACTIVE(afterNthActive(s(mark(x0)), mark(y1)))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U51ACTIVE(tt, U82(x0, x1), y1) → HEADACTIVE(afterNthActive(U82Active(mark(x0), x1), mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
U51ACTIVE(tt, y0, 0) → HEADACTIVE(afterNthActive(mark(y0), 0))
U51ACTIVE(tt, 0, y1) → HEADACTIVE(afterNthActive(0, mark(y1)))
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U51ACTIVE(tt, tail(x0), y1) → HEADACTIVE(afterNthActive(tailActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, snd(x0)) → HEADACTIVE(afterNthActive(mark(y0), sndActive(mark(x0))))
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, snd(x0), y1) → HEADACTIVE(afterNthActive(sndActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, natsFrom(x0), y1) → HEADACTIVE(afterNthActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, y0, s(x0)) → HEADACTIVE(afterNthActive(mark(y0), s(mark(x0))))
U51ACTIVE(tt, take(x0, x1), y1) → HEADACTIVE(afterNthActive(takeActive(mark(x0), mark(x1)), mark(y1)))
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, y0, nil) → HEADACTIVE(afterNthActive(mark(y0), nil))
U51ACTIVE(tt, nil, y1) → HEADACTIVE(afterNthActive(nil, mark(y1)))
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
U51ACTIVE(tt, y0, and(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), andActive(mark(x0), x1)))
U51ACTIVE(tt, U101(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
U51ACTIVE(tt, y0, tail(x0)) → HEADACTIVE(afterNthActive(mark(y0), tailActive(mark(x0))))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, afterNth(x0, x1), y1) → HEADACTIVE(afterNthActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
ISLNATACTIVE(take(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U51ACTIVE(tt, y0, U21(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U21Active(mark(x0), x1)))
U51ACTIVE(tt, U21(x0, x1), y1) → HEADACTIVE(afterNthActive(U21Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
ISPLNATACTIVE(splitAt(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → HEADACTIVE(afterNthActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
U51ACTIVE(tt, y0, splitAt(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U82(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U21(x1, x2)) → MARK(x1)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, y0, natsFrom(x0)) → HEADACTIVE(afterNthActive(mark(y0), natsFromActive(mark(x0))))
U51ACTIVE(tt, y0, isNatural(x0)) → HEADACTIVE(afterNthActive(mark(y0), isNaturalActive(x0)))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, N, XS) → MARK(XS)
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
U51ACTIVE(tt, y0, pair(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U51ACTIVE(tt, and(x0, x1), y1) → HEADACTIVE(afterNthActive(andActive(mark(x0), x1), mark(y1)))
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(snd(x1)) → MARK(x1)
U51ACTIVE(tt, isPLNat(x0), y1) → HEADACTIVE(afterNthActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, U71(x0, x1), y1) → HEADACTIVE(afterNthActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, y1) → HEADACTIVE(U11Active(andActive(isNaturalActive(mark(y0)), isLNat(mark(y1))), mark(y0), mark(y1)))
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(take(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
U51ACTIVE(tt, isLNat(x0), y1) → HEADACTIVE(afterNthActive(isLNatActive(x0), mark(y1)))
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U51ACTIVE(tt, fst(x0), y1) → HEADACTIVE(afterNthActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(take(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, y0, sel(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
ISPLNATACTIVE(splitAt(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U51ACTIVE(tt, U81(x0, x1, x2, x3), y1) → HEADACTIVE(afterNthActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, take(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, U11(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U11Active(mark(x0), x1, x2), mark(y1)))
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
U51ACTIVE(tt, U61(x0, x1), y1) → HEADACTIVE(afterNthActive(U61Active(mark(x0), x1), mark(y1)))
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U31(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
U51ACTIVE(tt, isNatural(x0), y1) → HEADACTIVE(afterNthActive(isNaturalActive(x0), mark(y1)))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(sel(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U51ACTIVE(tt, U31(x0, x1), y1) → HEADACTIVE(afterNthActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U51ACTIVE(tt, y0, afterNth(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, y0, fst(x0)) → HEADACTIVE(afterNthActive(mark(y0), fstActive(mark(x0))))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
ISPLNATACTIVE(splitAt(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
AFTERNTHACTIVE(head(x0), y1) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
U51ACTIVE(tt, y0, tt) → HEADACTIVE(afterNthActive(mark(y0), tt))
U51ACTIVE(tt, tt, y1) → HEADACTIVE(afterNthActive(tt, mark(y1)))
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
AFTERNTHACTIVE(0, y1) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U51ACTIVE(tt, y0, U41(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U41Active(mark(x0), x1)))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
AFTERNTHACTIVE(s(x0), y1) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U51(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U51Active(mark(x0), x1, x2)))
U51ACTIVE(tt, U91(x0, x1), y1) → HEADACTIVE(afterNthActive(U91Active(mark(x0), x1), mark(y1)))
MARK(snd(x1)) → SNDACTIVE(mark(x1))
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(take(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U51ACTIVE(tt, y0, U61(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
AFTERNTHACTIVE(sel(x0, x1), y1) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, y0, isLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isLNatActive(x0)))
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
U51ACTIVE(tt, U41(x0, x1), y1) → HEADACTIVE(afterNthActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, cons(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
U51ACTIVE(tt, splitAt(x0, x1), y1) → HEADACTIVE(afterNthActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, head(x0), y1) → HEADACTIVE(afterNthActive(headActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, cons(x0, x1), y1) → HEADACTIVE(afterNthActive(cons(mark(x0), x1), mark(y1)))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U51ACTIVE(tt, y0, isPLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isPLNatActive(x0)))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U51ACTIVE(tt, y0, U11(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U11Active(mark(x0), x1, x2)))
U31ACTIVE(tt, N) → MARK(N)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, y0, U71(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U71Active(mark(x0), x1)))
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U51ACTIVE(tt, pair(x0, x1), y1) → HEADACTIVE(afterNthActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, sel(x0, x1), y1) → HEADACTIVE(afterNthActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
ISPLNATACTIVE(splitAt(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(snd(x1)) → SNDACTIVE(mark(x1)) at position [0] we obtained the following new rules:

MARK(snd(U41(x0, x1))) → SNDACTIVE(U41Active(mark(x0), x1))
MARK(snd(U101(x0, x1, x2))) → SNDACTIVE(U101Active(mark(x0), x1, x2))
MARK(snd(U11(x0, x1, x2))) → SNDACTIVE(U11Active(mark(x0), x1, x2))
MARK(snd(and(x0, x1))) → SNDACTIVE(andActive(mark(x0), x1))
MARK(snd(U31(x0, x1))) → SNDACTIVE(U31Active(mark(x0), x1))
MARK(snd(afterNth(x0, x1))) → SNDACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(snd(sel(x0, x1))) → SNDACTIVE(selActive(mark(x0), mark(x1)))
MARK(snd(splitAt(x0, x1))) → SNDACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(snd(pair(x0, x1))) → SNDACTIVE(pair(mark(x0), mark(x1)))
MARK(snd(U61(x0, x1))) → SNDACTIVE(U61Active(mark(x0), x1))
MARK(snd(s(x0))) → SNDACTIVE(s(mark(x0)))
MARK(snd(U81(x0, x1, x2, x3))) → SNDACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(snd(snd(x0))) → SNDACTIVE(sndActive(mark(x0)))
MARK(snd(U71(x0, x1))) → SNDACTIVE(U71Active(mark(x0), x1))
MARK(snd(U51(x0, x1, x2))) → SNDACTIVE(U51Active(mark(x0), x1, x2))
MARK(snd(fst(x0))) → SNDACTIVE(fstActive(mark(x0)))
MARK(snd(isPLNat(x0))) → SNDACTIVE(isPLNatActive(x0))
MARK(snd(tail(x0))) → SNDACTIVE(tailActive(mark(x0)))
MARK(snd(head(x0))) → SNDACTIVE(headActive(mark(x0)))
MARK(snd(0)) → SNDACTIVE(0)
MARK(snd(natsFrom(x0))) → SNDACTIVE(natsFromActive(mark(x0)))
MARK(snd(U91(x0, x1))) → SNDACTIVE(U91Active(mark(x0), x1))
MARK(snd(take(x0, x1))) → SNDACTIVE(takeActive(mark(x0), mark(x1)))
MARK(snd(nil)) → SNDACTIVE(nil)
MARK(snd(U82(x0, x1))) → SNDACTIVE(U82Active(mark(x0), x1))
MARK(snd(isLNat(x0))) → SNDACTIVE(isLNatActive(x0))
MARK(snd(U21(x0, x1))) → SNDACTIVE(U21Active(mark(x0), x1))
MARK(snd(cons(x0, x1))) → SNDACTIVE(cons(mark(x0), x1))
MARK(snd(isNatural(x0))) → SNDACTIVE(isNaturalActive(x0))
MARK(snd(tt)) → SNDACTIVE(tt)



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(snd(U71(x0, x1))) → SNDACTIVE(U71Active(mark(x0), x1))
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U51ACTIVE(tt, U51(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(snd(isNatural(x0))) → SNDACTIVE(isNaturalActive(x0))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
MARK(snd(U101(x0, x1, x2))) → SNDACTIVE(U101Active(mark(x0), x1, x2))
U51ACTIVE(tt, y0, U101(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U101Active(mark(x0), x1, x2)))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(snd(U61(x0, x1))) → SNDACTIVE(U61Active(mark(x0), x1))
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U51ACTIVE(tt, y0, head(x0)) → HEADACTIVE(afterNthActive(mark(y0), headActive(mark(x0))))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
U51ACTIVE(tt, y0, U91(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U91Active(mark(x0), x1)))
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
MARK(snd(nil)) → SNDACTIVE(nil)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
U51ACTIVE(tt, s(x0), y1) → HEADACTIVE(afterNthActive(s(mark(x0)), mark(y1)))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U51ACTIVE(tt, U82(x0, x1), y1) → HEADACTIVE(afterNthActive(U82Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(snd(snd(x0))) → SNDACTIVE(sndActive(mark(x0)))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
U51ACTIVE(tt, 0, y1) → HEADACTIVE(afterNthActive(0, mark(y1)))
U51ACTIVE(tt, y0, 0) → HEADACTIVE(afterNthActive(mark(y0), 0))
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(snd(and(x0, x1))) → SNDACTIVE(andActive(mark(x0), x1))
MARK(snd(sel(x0, x1))) → SNDACTIVE(selActive(mark(x0), mark(x1)))
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
U51ACTIVE(tt, tail(x0), y1) → HEADACTIVE(afterNthActive(tailActive(mark(x0)), mark(y1)))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(snd(U91(x0, x1))) → SNDACTIVE(U91Active(mark(x0), x1))
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, snd(x0)) → HEADACTIVE(afterNthActive(mark(y0), sndActive(mark(x0))))
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, snd(x0), y1) → HEADACTIVE(afterNthActive(sndActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, natsFrom(x0), y1) → HEADACTIVE(afterNthActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
U51ACTIVE(tt, take(x0, x1), y1) → HEADACTIVE(afterNthActive(takeActive(mark(x0), mark(x1)), mark(y1)))
U51ACTIVE(tt, y0, s(x0)) → HEADACTIVE(afterNthActive(mark(y0), s(mark(x0))))
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
U51ACTIVE(tt, nil, y1) → HEADACTIVE(afterNthActive(nil, mark(y1)))
U51ACTIVE(tt, y0, nil) → HEADACTIVE(afterNthActive(mark(y0), nil))
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(snd(U82(x0, x1))) → SNDACTIVE(U82Active(mark(x0), x1))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U51ACTIVE(tt, y0, and(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), andActive(mark(x0), x1)))
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
U51ACTIVE(tt, U101(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(snd(pair(x0, x1))) → SNDACTIVE(pair(mark(x0), mark(x1)))
U51ACTIVE(tt, y0, tail(x0)) → HEADACTIVE(afterNthActive(mark(y0), tailActive(mark(x0))))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, afterNth(x0, x1), y1) → HEADACTIVE(afterNthActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(snd(isPLNat(x0))) → SNDACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(snd(head(x0))) → SNDACTIVE(headActive(mark(x0)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(take(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U51ACTIVE(tt, y0, U21(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U21Active(mark(x0), x1)))
MARK(snd(U21(x0, x1))) → SNDACTIVE(U21Active(mark(x0), x1))
U51ACTIVE(tt, U21(x0, x1), y1) → HEADACTIVE(afterNthActive(U21Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
ISPLNATACTIVE(splitAt(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(snd(U31(x0, x1))) → SNDACTIVE(U31Active(mark(x0), x1))
U51ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → HEADACTIVE(afterNthActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U91ACTIVE(tt, XS) → MARK(XS)
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
U51ACTIVE(tt, y0, splitAt(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
U51ACTIVE(tt, y0, U82(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
U51ACTIVE(tt, y0, natsFrom(x0)) → HEADACTIVE(afterNthActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, y0, isNatural(x0)) → HEADACTIVE(afterNthActive(mark(y0), isNaturalActive(x0)))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → MARK(XS)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
U51ACTIVE(tt, y0, pair(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
U51ACTIVE(tt, and(x0, x1), y1) → HEADACTIVE(afterNthActive(andActive(mark(x0), x1), mark(y1)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
U51ACTIVE(tt, isPLNat(x0), y1) → HEADACTIVE(afterNthActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, U71(x0, x1), y1) → HEADACTIVE(afterNthActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
MARK(snd(0)) → SNDACTIVE(0)
U51ACTIVE(tt, y0, y1) → HEADACTIVE(U11Active(andActive(isNaturalActive(mark(y0)), isLNat(mark(y1))), mark(y0), mark(y1)))
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(take(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
U51ACTIVE(tt, isLNat(x0), y1) → HEADACTIVE(afterNthActive(isLNatActive(x0), mark(y1)))
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
U51ACTIVE(tt, fst(x0), y1) → HEADACTIVE(afterNthActive(fstActive(mark(x0)), mark(y1)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(snd(splitAt(x0, x1))) → SNDACTIVE(splitAtActive(mark(x0), mark(x1)))
ISLNATACTIVE(take(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, y0, sel(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
U51ACTIVE(tt, U81(x0, x1, x2, x3), y1) → HEADACTIVE(afterNthActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
ISPLNATACTIVE(splitAt(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
U51ACTIVE(tt, y0, take(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(snd(tt)) → SNDACTIVE(tt)
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, U11(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U11Active(mark(x0), x1, x2), mark(y1)))
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(snd(U81(x0, x1, x2, x3))) → SNDACTIVE(U81Active(mark(x0), x1, x2, x3))
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U51ACTIVE(tt, U61(x0, x1), y1) → HEADACTIVE(afterNthActive(U61Active(mark(x0), x1), mark(y1)))
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(snd(take(x0, x1))) → SNDACTIVE(takeActive(mark(x0), mark(x1)))
U51ACTIVE(tt, y0, U31(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
MARK(snd(cons(x0, x1))) → SNDACTIVE(cons(mark(x0), x1))
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
U51ACTIVE(tt, isNatural(x0), y1) → HEADACTIVE(afterNthActive(isNaturalActive(x0), mark(y1)))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(snd(U51(x0, x1, x2))) → SNDACTIVE(U51Active(mark(x0), x1, x2))
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(snd(tail(x0))) → SNDACTIVE(tailActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
U51ACTIVE(tt, U31(x0, x1), y1) → HEADACTIVE(afterNthActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(snd(natsFrom(x0))) → SNDACTIVE(natsFromActive(mark(x0)))
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U51ACTIVE(tt, y0, afterNth(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, y0, fst(x0)) → HEADACTIVE(afterNthActive(mark(y0), fstActive(mark(x0))))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
ISPLNATACTIVE(splitAt(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(snd(isLNat(x0))) → SNDACTIVE(isLNatActive(x0))
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(snd(U11(x0, x1, x2))) → SNDACTIVE(U11Active(mark(x0), x1, x2))
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
AFTERNTHACTIVE(head(x0), y1) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U51ACTIVE(tt, tt, y1) → HEADACTIVE(afterNthActive(tt, mark(y1)))
U51ACTIVE(tt, y0, tt) → HEADACTIVE(afterNthActive(mark(y0), tt))
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(snd(U41(x0, x1))) → SNDACTIVE(U41Active(mark(x0), x1))
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
AFTERNTHACTIVE(0, y1) → ANDACTIVE(tt, isLNat(y1))
MARK(and(x1, x2)) → MARK(x1)
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U51ACTIVE(tt, y0, U41(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U41Active(mark(x0), x1)))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
AFTERNTHACTIVE(s(x0), y1) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, U91(x0, x1), y1) → HEADACTIVE(afterNthActive(U91Active(mark(x0), x1), mark(y1)))
U51ACTIVE(tt, y0, U51(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U61(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U61Active(mark(x0), x1)))
ISLNATACTIVE(take(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
AFTERNTHACTIVE(sel(x0, x1), y1) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U51ACTIVE(tt, y0, isLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isLNatActive(x0)))
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(snd(fst(x0))) → SNDACTIVE(fstActive(mark(x0)))
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
U51ACTIVE(tt, U41(x0, x1), y1) → HEADACTIVE(afterNthActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U51ACTIVE(tt, y0, cons(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
U51ACTIVE(tt, splitAt(x0, x1), y1) → HEADACTIVE(afterNthActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(snd(afterNth(x0, x1))) → SNDACTIVE(afterNthActive(mark(x0), mark(x1)))
U51ACTIVE(tt, head(x0), y1) → HEADACTIVE(afterNthActive(headActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, cons(x0, x1), y1) → HEADACTIVE(afterNthActive(cons(mark(x0), x1), mark(y1)))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U51ACTIVE(tt, y0, isPLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isPLNatActive(x0)))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U51ACTIVE(tt, y0, U11(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U11Active(mark(x0), x1, x2)))
MARK(snd(s(x0))) → SNDACTIVE(s(mark(x0)))
U31ACTIVE(tt, N) → MARK(N)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, y0, U71(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U71Active(mark(x0), x1)))
U51ACTIVE(tt, pair(x0, x1), y1) → HEADACTIVE(afterNthActive(pair(mark(x0), mark(x1)), mark(y1)))
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, sel(x0, x1), y1) → HEADACTIVE(afterNthActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
ISPLNATACTIVE(splitAt(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(snd(U71(x0, x1))) → SNDACTIVE(U71Active(mark(x0), x1))
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
U51ACTIVE(tt, U51(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(snd(isNatural(x0))) → SNDACTIVE(isNaturalActive(x0))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(snd(U101(x0, x1, x2))) → SNDACTIVE(U101Active(mark(x0), x1, x2))
U51ACTIVE(tt, y0, U101(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U101Active(mark(x0), x1, x2)))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(snd(U61(x0, x1))) → SNDACTIVE(U61Active(mark(x0), x1))
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U51ACTIVE(tt, y0, head(x0)) → HEADACTIVE(afterNthActive(mark(y0), headActive(mark(x0))))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
U51ACTIVE(tt, y0, U91(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U91Active(mark(x0), x1)))
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
U51ACTIVE(tt, s(x0), y1) → HEADACTIVE(afterNthActive(s(mark(x0)), mark(y1)))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U51ACTIVE(tt, U82(x0, x1), y1) → HEADACTIVE(afterNthActive(U82Active(mark(x0), x1), mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2))
MARK(snd(snd(x0))) → SNDACTIVE(sndActive(mark(x0)))
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
U51ACTIVE(tt, y0, 0) → HEADACTIVE(afterNthActive(mark(y0), 0))
U51ACTIVE(tt, 0, y1) → HEADACTIVE(afterNthActive(0, mark(y1)))
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(snd(and(x0, x1))) → SNDACTIVE(andActive(mark(x0), x1))
MARK(snd(sel(x0, x1))) → SNDACTIVE(selActive(mark(x0), mark(x1)))
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U51ACTIVE(tt, tail(x0), y1) → HEADACTIVE(afterNthActive(tailActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(snd(U91(x0, x1))) → SNDACTIVE(U91Active(mark(x0), x1))
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, snd(x0)) → HEADACTIVE(afterNthActive(mark(y0), sndActive(mark(x0))))
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, snd(x0), y1) → HEADACTIVE(afterNthActive(sndActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, natsFrom(x0), y1) → HEADACTIVE(afterNthActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, y0, s(x0)) → HEADACTIVE(afterNthActive(mark(y0), s(mark(x0))))
U51ACTIVE(tt, take(x0, x1), y1) → HEADACTIVE(afterNthActive(takeActive(mark(x0), mark(x1)), mark(y1)))
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, y0, nil) → HEADACTIVE(afterNthActive(mark(y0), nil))
U51ACTIVE(tt, nil, y1) → HEADACTIVE(afterNthActive(nil, mark(y1)))
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(snd(U82(x0, x1))) → SNDACTIVE(U82Active(mark(x0), x1))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
U51ACTIVE(tt, y0, and(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), andActive(mark(x0), x1)))
U51ACTIVE(tt, U101(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(snd(pair(x0, x1))) → SNDACTIVE(pair(mark(x0), mark(x1)))
U51ACTIVE(tt, y0, tail(x0)) → HEADACTIVE(afterNthActive(mark(y0), tailActive(mark(x0))))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, afterNth(x0, x1), y1) → HEADACTIVE(afterNthActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
MARK(snd(isPLNat(x0))) → SNDACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(snd(head(x0))) → SNDACTIVE(headActive(mark(x0)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
ISLNATACTIVE(take(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U51ACTIVE(tt, y0, U21(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U21Active(mark(x0), x1)))
MARK(snd(U21(x0, x1))) → SNDACTIVE(U21Active(mark(x0), x1))
U51ACTIVE(tt, U21(x0, x1), y1) → HEADACTIVE(afterNthActive(U21Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
ISPLNATACTIVE(splitAt(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(snd(U31(x0, x1))) → SNDACTIVE(U31Active(mark(x0), x1))
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → HEADACTIVE(afterNthActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
U51ACTIVE(tt, y0, splitAt(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U82(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U21(x1, x2)) → MARK(x1)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, y0, natsFrom(x0)) → HEADACTIVE(afterNthActive(mark(y0), natsFromActive(mark(x0))))
U51ACTIVE(tt, y0, isNatural(x0)) → HEADACTIVE(afterNthActive(mark(y0), isNaturalActive(x0)))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, N, XS) → MARK(XS)
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
U51ACTIVE(tt, y0, pair(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U51ACTIVE(tt, and(x0, x1), y1) → HEADACTIVE(afterNthActive(andActive(mark(x0), x1), mark(y1)))
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(snd(x1)) → MARK(x1)
U51ACTIVE(tt, isPLNat(x0), y1) → HEADACTIVE(afterNthActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, U71(x0, x1), y1) → HEADACTIVE(afterNthActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, y1) → HEADACTIVE(U11Active(andActive(isNaturalActive(mark(y0)), isLNat(mark(y1))), mark(y0), mark(y1)))
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(take(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
U51ACTIVE(tt, isLNat(x0), y1) → HEADACTIVE(afterNthActive(isLNatActive(x0), mark(y1)))
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U51ACTIVE(tt, fst(x0), y1) → HEADACTIVE(afterNthActive(fstActive(mark(x0)), mark(y1)))
MARK(snd(splitAt(x0, x1))) → SNDACTIVE(splitAtActive(mark(x0), mark(x1)))
ISLNATACTIVE(take(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, y0, sel(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
ISPLNATACTIVE(splitAt(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U51ACTIVE(tt, U81(x0, x1, x2, x3), y1) → HEADACTIVE(afterNthActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, take(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, U11(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U11Active(mark(x0), x1, x2), mark(y1)))
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(snd(U81(x0, x1, x2, x3))) → SNDACTIVE(U81Active(mark(x0), x1, x2, x3))
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
U51ACTIVE(tt, U61(x0, x1), y1) → HEADACTIVE(afterNthActive(U61Active(mark(x0), x1), mark(y1)))
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(snd(take(x0, x1))) → SNDACTIVE(takeActive(mark(x0), mark(x1)))
U51ACTIVE(tt, y0, U31(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
U51ACTIVE(tt, isNatural(x0), y1) → HEADACTIVE(afterNthActive(isNaturalActive(x0), mark(y1)))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(snd(U51(x0, x1, x2))) → SNDACTIVE(U51Active(mark(x0), x1, x2))
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(snd(tail(x0))) → SNDACTIVE(tailActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U51ACTIVE(tt, U31(x0, x1), y1) → HEADACTIVE(afterNthActive(U31Active(mark(x0), x1), mark(y1)))
MARK(snd(natsFrom(x0))) → SNDACTIVE(natsFromActive(mark(x0)))
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U51ACTIVE(tt, y0, afterNth(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, y0, fst(x0)) → HEADACTIVE(afterNthActive(mark(y0), fstActive(mark(x0))))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
ISPLNATACTIVE(splitAt(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(snd(isLNat(x0))) → SNDACTIVE(isLNatActive(x0))
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(snd(U11(x0, x1, x2))) → SNDACTIVE(U11Active(mark(x0), x1, x2))
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
AFTERNTHACTIVE(head(x0), y1) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
U51ACTIVE(tt, y0, tt) → HEADACTIVE(afterNthActive(mark(y0), tt))
U51ACTIVE(tt, tt, y1) → HEADACTIVE(afterNthActive(tt, mark(y1)))
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(snd(U41(x0, x1))) → SNDACTIVE(U41Active(mark(x0), x1))
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
AFTERNTHACTIVE(0, y1) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U51ACTIVE(tt, y0, U41(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U41Active(mark(x0), x1)))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
AFTERNTHACTIVE(s(x0), y1) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U51(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U51Active(mark(x0), x1, x2)))
U51ACTIVE(tt, U91(x0, x1), y1) → HEADACTIVE(afterNthActive(U91Active(mark(x0), x1), mark(y1)))
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(take(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U51ACTIVE(tt, y0, U61(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
AFTERNTHACTIVE(sel(x0, x1), y1) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, y0, isLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isLNatActive(x0)))
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(snd(fst(x0))) → SNDACTIVE(fstActive(mark(x0)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
U51ACTIVE(tt, U41(x0, x1), y1) → HEADACTIVE(afterNthActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, cons(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
U51ACTIVE(tt, splitAt(x0, x1), y1) → HEADACTIVE(afterNthActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(snd(afterNth(x0, x1))) → SNDACTIVE(afterNthActive(mark(x0), mark(x1)))
U51ACTIVE(tt, head(x0), y1) → HEADACTIVE(afterNthActive(headActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, cons(x0, x1), y1) → HEADACTIVE(afterNthActive(cons(mark(x0), x1), mark(y1)))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U51ACTIVE(tt, y0, isPLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isPLNatActive(x0)))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U51ACTIVE(tt, y0, U11(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U11Active(mark(x0), x1, x2)))
U31ACTIVE(tt, N) → MARK(N)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, y0, U71(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U71Active(mark(x0), x1)))
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U51ACTIVE(tt, pair(x0, x1), y1) → HEADACTIVE(afterNthActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, sel(x0, x1), y1) → HEADACTIVE(afterNthActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
ISPLNATACTIVE(splitAt(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(splitAt(x1, x2)) → SPLITATACTIVE(mark(x1), mark(x2)) at position [0] we obtained the following new rules:

MARK(splitAt(U11(x0, x1, x2), y1)) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(splitAt(U71(x0, x1), y1)) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(splitAt(sel(x0, x1), y1)) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(splitAt(U91(x0, x1), y1)) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(splitAt(U21(x0, x1), y1)) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(splitAt(U81(x0, x1, x2, x3), y1)) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(splitAt(nil, y1)) → SPLITATACTIVE(nil, mark(y1))
MARK(splitAt(cons(x0, x1), y1)) → SPLITATACTIVE(cons(mark(x0), x1), mark(y1))
MARK(splitAt(isPLNat(x0), y1)) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(splitAt(tt, y1)) → SPLITATACTIVE(tt, mark(y1))
MARK(splitAt(splitAt(x0, x1), y1)) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(splitAt(fst(x0), y1)) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(splitAt(pair(x0, x1), y1)) → SPLITATACTIVE(pair(mark(x0), mark(x1)), mark(y1))
MARK(splitAt(U31(x0, x1), y1)) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(splitAt(U82(x0, x1), y1)) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(splitAt(U51(x0, x1, x2), y1)) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(splitAt(take(x0, x1), y1)) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(splitAt(U101(x0, x1, x2), y1)) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(splitAt(0, y1)) → SPLITATACTIVE(0, mark(y1))
MARK(splitAt(snd(x0), y1)) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
MARK(splitAt(tail(x0), y1)) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(splitAt(isLNat(x0), y1)) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
MARK(splitAt(and(x0, x1), y1)) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
MARK(splitAt(natsFrom(x0), y1)) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(splitAt(U41(x0, x1), y1)) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(splitAt(isNatural(x0), y1)) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(splitAt(U61(x0, x1), y1)) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(splitAt(head(x0), y1)) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(splitAt(s(x0), y1)) → SPLITATACTIVE(s(mark(x0)), mark(y1))
MARK(splitAt(afterNth(x0, x1), y1)) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(snd(U71(x0, x1))) → SNDACTIVE(U71Active(mark(x0), x1))
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(splitAt(U82(x0, x1), y1)) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(splitAt(U101(x0, x1, x2), y1)) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U51ACTIVE(tt, U51(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(snd(isNatural(x0))) → SNDACTIVE(isNaturalActive(x0))
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
MARK(splitAt(U91(x0, x1), y1)) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(snd(U101(x0, x1, x2))) → SNDACTIVE(U101Active(mark(x0), x1, x2))
U51ACTIVE(tt, y0, U101(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U101Active(mark(x0), x1, x2)))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(snd(U61(x0, x1))) → SNDACTIVE(U61Active(mark(x0), x1))
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U51ACTIVE(tt, y0, head(x0)) → HEADACTIVE(afterNthActive(mark(y0), headActive(mark(x0))))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(splitAt(0, y1)) → SPLITATACTIVE(0, mark(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
U51ACTIVE(tt, y0, U91(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U91Active(mark(x0), x1)))
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
U51ACTIVE(tt, s(x0), y1) → HEADACTIVE(afterNthActive(s(mark(x0)), mark(y1)))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U51ACTIVE(tt, U82(x0, x1), y1) → HEADACTIVE(afterNthActive(U82Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(splitAt(isPLNat(x0), y1)) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(snd(snd(x0))) → SNDACTIVE(sndActive(mark(x0)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
U51ACTIVE(tt, 0, y1) → HEADACTIVE(afterNthActive(0, mark(y1)))
U51ACTIVE(tt, y0, 0) → HEADACTIVE(afterNthActive(mark(y0), 0))
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(snd(and(x0, x1))) → SNDACTIVE(andActive(mark(x0), x1))
MARK(snd(sel(x0, x1))) → SNDACTIVE(selActive(mark(x0), mark(x1)))
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
U51ACTIVE(tt, tail(x0), y1) → HEADACTIVE(afterNthActive(tailActive(mark(x0)), mark(y1)))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(snd(U91(x0, x1))) → SNDACTIVE(U91Active(mark(x0), x1))
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, snd(x0)) → HEADACTIVE(afterNthActive(mark(y0), sndActive(mark(x0))))
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, snd(x0), y1) → HEADACTIVE(afterNthActive(sndActive(mark(x0)), mark(y1)))
MARK(splitAt(tt, y1)) → SPLITATACTIVE(tt, mark(y1))
U51ACTIVE(tt, natsFrom(x0), y1) → HEADACTIVE(afterNthActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
U51ACTIVE(tt, take(x0, x1), y1) → HEADACTIVE(afterNthActive(takeActive(mark(x0), mark(x1)), mark(y1)))
U51ACTIVE(tt, y0, s(x0)) → HEADACTIVE(afterNthActive(mark(y0), s(mark(x0))))
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
U51ACTIVE(tt, nil, y1) → HEADACTIVE(afterNthActive(nil, mark(y1)))
U51ACTIVE(tt, y0, nil) → HEADACTIVE(afterNthActive(mark(y0), nil))
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(snd(U82(x0, x1))) → SNDACTIVE(U82Active(mark(x0), x1))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U51ACTIVE(tt, y0, and(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), andActive(mark(x0), x1)))
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
U51ACTIVE(tt, U101(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(snd(pair(x0, x1))) → SNDACTIVE(pair(mark(x0), mark(x1)))
U51ACTIVE(tt, y0, tail(x0)) → HEADACTIVE(afterNthActive(mark(y0), tailActive(mark(x0))))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, afterNth(x0, x1), y1) → HEADACTIVE(afterNthActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(snd(isPLNat(x0))) → SNDACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(snd(head(x0))) → SNDACTIVE(headActive(mark(x0)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(take(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U51ACTIVE(tt, y0, U21(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U21Active(mark(x0), x1)))
MARK(splitAt(U61(x0, x1), y1)) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(snd(U21(x0, x1))) → SNDACTIVE(U21Active(mark(x0), x1))
U51ACTIVE(tt, U21(x0, x1), y1) → HEADACTIVE(afterNthActive(U21Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
ISPLNATACTIVE(splitAt(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(snd(U31(x0, x1))) → SNDACTIVE(U31Active(mark(x0), x1))
U51ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → HEADACTIVE(afterNthActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
MARK(splitAt(pair(x0, x1), y1)) → SPLITATACTIVE(pair(mark(x0), mark(x1)), mark(y1))
U91ACTIVE(tt, XS) → MARK(XS)
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
U51ACTIVE(tt, y0, splitAt(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
U51ACTIVE(tt, y0, U82(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
U51ACTIVE(tt, y0, natsFrom(x0)) → HEADACTIVE(afterNthActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, y0, isNatural(x0)) → HEADACTIVE(afterNthActive(mark(y0), isNaturalActive(x0)))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → MARK(XS)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
MARK(splitAt(U11(x0, x1, x2), y1)) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(splitAt(sel(x0, x1), y1)) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
U51ACTIVE(tt, y0, pair(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
U51ACTIVE(tt, and(x0, x1), y1) → HEADACTIVE(afterNthActive(andActive(mark(x0), x1), mark(y1)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
U51ACTIVE(tt, isPLNat(x0), y1) → HEADACTIVE(afterNthActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, U71(x0, x1), y1) → HEADACTIVE(afterNthActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, y1) → HEADACTIVE(U11Active(andActive(isNaturalActive(mark(y0)), isLNat(mark(y1))), mark(y0), mark(y1)))
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(take(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
U51ACTIVE(tt, isLNat(x0), y1) → HEADACTIVE(afterNthActive(isLNatActive(x0), mark(y1)))
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
U51ACTIVE(tt, fst(x0), y1) → HEADACTIVE(afterNthActive(fstActive(mark(x0)), mark(y1)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(snd(splitAt(x0, x1))) → SNDACTIVE(splitAtActive(mark(x0), mark(x1)))
ISLNATACTIVE(take(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, y0, sel(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
U51ACTIVE(tt, U81(x0, x1, x2, x3), y1) → HEADACTIVE(afterNthActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
ISPLNATACTIVE(splitAt(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
U51ACTIVE(tt, y0, take(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, U11(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U11Active(mark(x0), x1, x2), mark(y1)))
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(splitAt(splitAt(x0, x1), y1)) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(snd(U81(x0, x1, x2, x3))) → SNDACTIVE(U81Active(mark(x0), x1, x2, x3))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U51ACTIVE(tt, U61(x0, x1), y1) → HEADACTIVE(afterNthActive(U61Active(mark(x0), x1), mark(y1)))
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(splitAt(snd(x0), y1)) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U31(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U31Active(mark(x0), x1)))
MARK(snd(take(x0, x1))) → SNDACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(splitAt(U21(x0, x1), y1)) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(splitAt(U81(x0, x1, x2, x3), y1)) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U51ACTIVE(tt, isNatural(x0), y1) → HEADACTIVE(afterNthActive(isNaturalActive(x0), mark(y1)))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(splitAt(nil, y1)) → SPLITATACTIVE(nil, mark(y1))
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(splitAt(cons(x0, x1), y1)) → SPLITATACTIVE(cons(mark(x0), x1), mark(y1))
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(snd(U51(x0, x1, x2))) → SNDACTIVE(U51Active(mark(x0), x1, x2))
MARK(splitAt(take(x0, x1), y1)) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(snd(tail(x0))) → SNDACTIVE(tailActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(splitAt(tail(x0), y1)) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
U51ACTIVE(tt, U31(x0, x1), y1) → HEADACTIVE(afterNthActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(snd(natsFrom(x0))) → SNDACTIVE(natsFromActive(mark(x0)))
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U51ACTIVE(tt, y0, afterNth(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, y0, fst(x0)) → HEADACTIVE(afterNthActive(mark(y0), fstActive(mark(x0))))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
ISPLNATACTIVE(splitAt(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(splitAt(U41(x0, x1), y1)) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(snd(isLNat(x0))) → SNDACTIVE(isLNatActive(x0))
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(splitAt(s(x0), y1)) → SPLITATACTIVE(s(mark(x0)), mark(y1))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(splitAt(afterNth(x0, x1), y1)) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(snd(U11(x0, x1, x2))) → SNDACTIVE(U11Active(mark(x0), x1, x2))
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
AFTERNTHACTIVE(head(x0), y1) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(splitAt(isNatural(x0), y1)) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(splitAt(head(x0), y1)) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
U51ACTIVE(tt, tt, y1) → HEADACTIVE(afterNthActive(tt, mark(y1)))
U51ACTIVE(tt, y0, tt) → HEADACTIVE(afterNthActive(mark(y0), tt))
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(snd(U41(x0, x1))) → SNDACTIVE(U41Active(mark(x0), x1))
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
AFTERNTHACTIVE(0, y1) → ANDACTIVE(tt, isLNat(y1))
MARK(and(x1, x2)) → MARK(x1)
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U51ACTIVE(tt, y0, U41(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U41Active(mark(x0), x1)))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(splitAt(natsFrom(x0), y1)) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
AFTERNTHACTIVE(s(x0), y1) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, U91(x0, x1), y1) → HEADACTIVE(afterNthActive(U91Active(mark(x0), x1), mark(y1)))
U51ACTIVE(tt, y0, U51(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U61(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U61Active(mark(x0), x1)))
ISLNATACTIVE(take(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(splitAt(fst(x0), y1)) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
AFTERNTHACTIVE(sel(x0, x1), y1) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U51ACTIVE(tt, y0, isLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isLNatActive(x0)))
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
MARK(snd(fst(x0))) → SNDACTIVE(fstActive(mark(x0)))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
U51ACTIVE(tt, U41(x0, x1), y1) → HEADACTIVE(afterNthActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(splitAt(isLNat(x0), y1)) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U51ACTIVE(tt, y0, cons(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
U51ACTIVE(tt, splitAt(x0, x1), y1) → HEADACTIVE(afterNthActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(splitAt(U71(x0, x1), y1)) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
U51ACTIVE(tt, head(x0), y1) → HEADACTIVE(afterNthActive(headActive(mark(x0)), mark(y1)))
MARK(snd(afterNth(x0, x1))) → SNDACTIVE(afterNthActive(mark(x0), mark(x1)))
U51ACTIVE(tt, cons(x0, x1), y1) → HEADACTIVE(afterNthActive(cons(mark(x0), x1), mark(y1)))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U51ACTIVE(tt, y0, isPLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isPLNatActive(x0)))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U51ACTIVE(tt, y0, U11(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U11Active(mark(x0), x1, x2)))
U31ACTIVE(tt, N) → MARK(N)
MARK(splitAt(U31(x0, x1), y1)) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(splitAt(U51(x0, x1, x2), y1)) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, y0, U71(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U71Active(mark(x0), x1)))
U51ACTIVE(tt, pair(x0, x1), y1) → HEADACTIVE(afterNthActive(pair(mark(x0), mark(x1)), mark(y1)))
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
MARK(splitAt(and(x0, x1), y1)) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, sel(x0, x1), y1) → HEADACTIVE(afterNthActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
ISPLNATACTIVE(splitAt(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 4 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(snd(U71(x0, x1))) → SNDACTIVE(U71Active(mark(x0), x1))
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(splitAt(U82(x0, x1), y1)) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(splitAt(U101(x0, x1, x2), y1)) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
U51ACTIVE(tt, U51(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(snd(isNatural(x0))) → SNDACTIVE(isNaturalActive(x0))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(splitAt(U91(x0, x1), y1)) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(snd(U101(x0, x1, x2))) → SNDACTIVE(U101Active(mark(x0), x1, x2))
U51ACTIVE(tt, y0, U101(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U101Active(mark(x0), x1, x2)))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(snd(U61(x0, x1))) → SNDACTIVE(U61Active(mark(x0), x1))
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U51ACTIVE(tt, y0, head(x0)) → HEADACTIVE(afterNthActive(mark(y0), headActive(mark(x0))))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(splitAt(0, y1)) → SPLITATACTIVE(0, mark(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
U51ACTIVE(tt, y0, U91(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U91Active(mark(x0), x1)))
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
U51ACTIVE(tt, s(x0), y1) → HEADACTIVE(afterNthActive(s(mark(x0)), mark(y1)))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U51ACTIVE(tt, U82(x0, x1), y1) → HEADACTIVE(afterNthActive(U82Active(mark(x0), x1), mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(splitAt(isPLNat(x0), y1)) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(snd(snd(x0))) → SNDACTIVE(sndActive(mark(x0)))
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
U51ACTIVE(tt, y0, 0) → HEADACTIVE(afterNthActive(mark(y0), 0))
U51ACTIVE(tt, 0, y1) → HEADACTIVE(afterNthActive(0, mark(y1)))
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(snd(and(x0, x1))) → SNDACTIVE(andActive(mark(x0), x1))
MARK(snd(sel(x0, x1))) → SNDACTIVE(selActive(mark(x0), mark(x1)))
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U51ACTIVE(tt, tail(x0), y1) → HEADACTIVE(afterNthActive(tailActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(snd(U91(x0, x1))) → SNDACTIVE(U91Active(mark(x0), x1))
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, snd(x0)) → HEADACTIVE(afterNthActive(mark(y0), sndActive(mark(x0))))
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, snd(x0), y1) → HEADACTIVE(afterNthActive(sndActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, natsFrom(x0), y1) → HEADACTIVE(afterNthActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, y0, s(x0)) → HEADACTIVE(afterNthActive(mark(y0), s(mark(x0))))
U51ACTIVE(tt, take(x0, x1), y1) → HEADACTIVE(afterNthActive(takeActive(mark(x0), mark(x1)), mark(y1)))
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, y0, nil) → HEADACTIVE(afterNthActive(mark(y0), nil))
U51ACTIVE(tt, nil, y1) → HEADACTIVE(afterNthActive(nil, mark(y1)))
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(snd(U82(x0, x1))) → SNDACTIVE(U82Active(mark(x0), x1))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
U51ACTIVE(tt, y0, and(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), andActive(mark(x0), x1)))
U51ACTIVE(tt, U101(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(snd(pair(x0, x1))) → SNDACTIVE(pair(mark(x0), mark(x1)))
U51ACTIVE(tt, y0, tail(x0)) → HEADACTIVE(afterNthActive(mark(y0), tailActive(mark(x0))))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, afterNth(x0, x1), y1) → HEADACTIVE(afterNthActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
MARK(snd(isPLNat(x0))) → SNDACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(snd(head(x0))) → SNDACTIVE(headActive(mark(x0)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
ISLNATACTIVE(take(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U51ACTIVE(tt, y0, U21(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U21Active(mark(x0), x1)))
MARK(splitAt(U61(x0, x1), y1)) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(snd(U21(x0, x1))) → SNDACTIVE(U21Active(mark(x0), x1))
U51ACTIVE(tt, U21(x0, x1), y1) → HEADACTIVE(afterNthActive(U21Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
ISPLNATACTIVE(splitAt(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(snd(U31(x0, x1))) → SNDACTIVE(U31Active(mark(x0), x1))
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → HEADACTIVE(afterNthActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
U51ACTIVE(tt, y0, splitAt(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U82(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U21(x1, x2)) → MARK(x1)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, y0, natsFrom(x0)) → HEADACTIVE(afterNthActive(mark(y0), natsFromActive(mark(x0))))
U51ACTIVE(tt, y0, isNatural(x0)) → HEADACTIVE(afterNthActive(mark(y0), isNaturalActive(x0)))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(splitAt(U11(x0, x1, x2), y1)) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(splitAt(sel(x0, x1), y1)) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
U51ACTIVE(tt, y0, pair(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U51ACTIVE(tt, and(x0, x1), y1) → HEADACTIVE(afterNthActive(andActive(mark(x0), x1), mark(y1)))
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(snd(x1)) → MARK(x1)
U51ACTIVE(tt, isPLNat(x0), y1) → HEADACTIVE(afterNthActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, U71(x0, x1), y1) → HEADACTIVE(afterNthActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, y1) → HEADACTIVE(U11Active(andActive(isNaturalActive(mark(y0)), isLNat(mark(y1))), mark(y0), mark(y1)))
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(take(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
U51ACTIVE(tt, isLNat(x0), y1) → HEADACTIVE(afterNthActive(isLNatActive(x0), mark(y1)))
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U51ACTIVE(tt, fst(x0), y1) → HEADACTIVE(afterNthActive(fstActive(mark(x0)), mark(y1)))
MARK(snd(splitAt(x0, x1))) → SNDACTIVE(splitAtActive(mark(x0), mark(x1)))
ISLNATACTIVE(take(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, y0, sel(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
ISPLNATACTIVE(splitAt(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U51ACTIVE(tt, U81(x0, x1, x2, x3), y1) → HEADACTIVE(afterNthActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, take(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, U11(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U11Active(mark(x0), x1, x2), mark(y1)))
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(splitAt(splitAt(x0, x1), y1)) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(snd(U81(x0, x1, x2, x3))) → SNDACTIVE(U81Active(mark(x0), x1, x2, x3))
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
U51ACTIVE(tt, U61(x0, x1), y1) → HEADACTIVE(afterNthActive(U61Active(mark(x0), x1), mark(y1)))
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(splitAt(snd(x0), y1)) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(snd(take(x0, x1))) → SNDACTIVE(takeActive(mark(x0), mark(x1)))
U51ACTIVE(tt, y0, U31(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(splitAt(U21(x0, x1), y1)) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(splitAt(U81(x0, x1, x2, x3), y1)) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U51ACTIVE(tt, isNatural(x0), y1) → HEADACTIVE(afterNthActive(isNaturalActive(x0), mark(y1)))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(snd(U51(x0, x1, x2))) → SNDACTIVE(U51Active(mark(x0), x1, x2))
MARK(splitAt(take(x0, x1), y1)) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(snd(tail(x0))) → SNDACTIVE(tailActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(splitAt(tail(x0), y1)) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U51ACTIVE(tt, U31(x0, x1), y1) → HEADACTIVE(afterNthActive(U31Active(mark(x0), x1), mark(y1)))
MARK(snd(natsFrom(x0))) → SNDACTIVE(natsFromActive(mark(x0)))
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U51ACTIVE(tt, y0, afterNth(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, y0, fst(x0)) → HEADACTIVE(afterNthActive(mark(y0), fstActive(mark(x0))))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
ISPLNATACTIVE(splitAt(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(splitAt(U41(x0, x1), y1)) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(snd(isLNat(x0))) → SNDACTIVE(isLNatActive(x0))
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(splitAt(s(x0), y1)) → SPLITATACTIVE(s(mark(x0)), mark(y1))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(splitAt(afterNth(x0, x1), y1)) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(snd(U11(x0, x1, x2))) → SNDACTIVE(U11Active(mark(x0), x1, x2))
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
AFTERNTHACTIVE(head(x0), y1) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(splitAt(isNatural(x0), y1)) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(splitAt(head(x0), y1)) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
U51ACTIVE(tt, y0, tt) → HEADACTIVE(afterNthActive(mark(y0), tt))
U51ACTIVE(tt, tt, y1) → HEADACTIVE(afterNthActive(tt, mark(y1)))
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(snd(U41(x0, x1))) → SNDACTIVE(U41Active(mark(x0), x1))
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
AFTERNTHACTIVE(0, y1) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U51ACTIVE(tt, y0, U41(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U41Active(mark(x0), x1)))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(splitAt(natsFrom(x0), y1)) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
AFTERNTHACTIVE(s(x0), y1) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U51(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U51Active(mark(x0), x1, x2)))
U51ACTIVE(tt, U91(x0, x1), y1) → HEADACTIVE(afterNthActive(U91Active(mark(x0), x1), mark(y1)))
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(take(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U51ACTIVE(tt, y0, U61(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(splitAt(fst(x0), y1)) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
AFTERNTHACTIVE(sel(x0, x1), y1) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, y0, isLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isLNatActive(x0)))
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(snd(fst(x0))) → SNDACTIVE(fstActive(mark(x0)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
U51ACTIVE(tt, U41(x0, x1), y1) → HEADACTIVE(afterNthActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(splitAt(isLNat(x0), y1)) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, cons(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
U51ACTIVE(tt, splitAt(x0, x1), y1) → HEADACTIVE(afterNthActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(splitAt(U71(x0, x1), y1)) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(snd(afterNth(x0, x1))) → SNDACTIVE(afterNthActive(mark(x0), mark(x1)))
U51ACTIVE(tt, head(x0), y1) → HEADACTIVE(afterNthActive(headActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, cons(x0, x1), y1) → HEADACTIVE(afterNthActive(cons(mark(x0), x1), mark(y1)))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U51ACTIVE(tt, y0, isPLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isPLNatActive(x0)))
MARK(tail(x1)) → TAILACTIVE(mark(x1))
U51ACTIVE(tt, y0, U11(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U11Active(mark(x0), x1, x2)))
U31ACTIVE(tt, N) → MARK(N)
MARK(splitAt(U31(x0, x1), y1)) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(splitAt(U51(x0, x1, x2), y1)) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, y0, U71(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U71Active(mark(x0), x1)))
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U51ACTIVE(tt, pair(x0, x1), y1) → HEADACTIVE(afterNthActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(splitAt(and(x0, x1), y1)) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, sel(x0, x1), y1) → HEADACTIVE(afterNthActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
ISPLNATACTIVE(splitAt(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule MARK(tail(x1)) → TAILACTIVE(mark(x1)) at position [0] we obtained the following new rules:

MARK(tail(s(x0))) → TAILACTIVE(s(mark(x0)))
MARK(tail(U101(x0, x1, x2))) → TAILACTIVE(U101Active(mark(x0), x1, x2))
MARK(tail(afterNth(x0, x1))) → TAILACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(tail(take(x0, x1))) → TAILACTIVE(takeActive(mark(x0), mark(x1)))
MARK(tail(and(x0, x1))) → TAILACTIVE(andActive(mark(x0), x1))
MARK(tail(pair(x0, x1))) → TAILACTIVE(pair(mark(x0), mark(x1)))
MARK(tail(isLNat(x0))) → TAILACTIVE(isLNatActive(x0))
MARK(tail(snd(x0))) → TAILACTIVE(sndActive(mark(x0)))
MARK(tail(U51(x0, x1, x2))) → TAILACTIVE(U51Active(mark(x0), x1, x2))
MARK(tail(fst(x0))) → TAILACTIVE(fstActive(mark(x0)))
MARK(tail(U41(x0, x1))) → TAILACTIVE(U41Active(mark(x0), x1))
MARK(tail(U61(x0, x1))) → TAILACTIVE(U61Active(mark(x0), x1))
MARK(tail(0)) → TAILACTIVE(0)
MARK(tail(natsFrom(x0))) → TAILACTIVE(natsFromActive(mark(x0)))
MARK(tail(U82(x0, x1))) → TAILACTIVE(U82Active(mark(x0), x1))
MARK(tail(U21(x0, x1))) → TAILACTIVE(U21Active(mark(x0), x1))
MARK(tail(tt)) → TAILACTIVE(tt)
MARK(tail(isPLNat(x0))) → TAILACTIVE(isPLNatActive(x0))
MARK(tail(sel(x0, x1))) → TAILACTIVE(selActive(mark(x0), mark(x1)))
MARK(tail(isNatural(x0))) → TAILACTIVE(isNaturalActive(x0))
MARK(tail(U81(x0, x1, x2, x3))) → TAILACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(tail(U91(x0, x1))) → TAILACTIVE(U91Active(mark(x0), x1))
MARK(tail(U11(x0, x1, x2))) → TAILACTIVE(U11Active(mark(x0), x1, x2))
MARK(tail(U31(x0, x1))) → TAILACTIVE(U31Active(mark(x0), x1))
MARK(tail(cons(x0, x1))) → TAILACTIVE(cons(mark(x0), x1))
MARK(tail(nil)) → TAILACTIVE(nil)
MARK(tail(U71(x0, x1))) → TAILACTIVE(U71Active(mark(x0), x1))
MARK(tail(head(x0))) → TAILACTIVE(headActive(mark(x0)))
MARK(tail(splitAt(x0, x1))) → TAILACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(tail(tail(x0))) → TAILACTIVE(tailActive(mark(x0)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(tail(s(x0))) → TAILACTIVE(s(mark(x0)))
MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(tail(take(x0, x1))) → TAILACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(tail(and(x0, x1))) → TAILACTIVE(andActive(mark(x0), x1))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(snd(U71(x0, x1))) → SNDACTIVE(U71Active(mark(x0), x1))
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(splitAt(U82(x0, x1), y1)) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
MARK(splitAt(U101(x0, x1, x2), y1)) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
MARK(tail(U91(x0, x1))) → TAILACTIVE(U91Active(mark(x0), x1))
U51ACTIVE(tt, U51(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(tail(nil)) → TAILACTIVE(nil)
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(snd(isNatural(x0))) → SNDACTIVE(isNaturalActive(x0))
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
MARK(snd(U101(x0, x1, x2))) → SNDACTIVE(U101Active(mark(x0), x1, x2))
MARK(splitAt(U91(x0, x1), y1)) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
U51ACTIVE(tt, y0, U101(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U101Active(mark(x0), x1, x2)))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(snd(U61(x0, x1))) → SNDACTIVE(U61Active(mark(x0), x1))
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U51ACTIVE(tt, y0, head(x0)) → HEADACTIVE(afterNthActive(mark(y0), headActive(mark(x0))))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(splitAt(0, y1)) → SPLITATACTIVE(0, mark(y1))
U51ACTIVE(tt, y0, U91(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U91Active(mark(x0), x1)))
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
U51ACTIVE(tt, s(x0), y1) → HEADACTIVE(afterNthActive(s(mark(x0)), mark(y1)))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(tail(tail(x0))) → TAILACTIVE(tailActive(mark(x0)))
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U51ACTIVE(tt, U82(x0, x1), y1) → HEADACTIVE(afterNthActive(U82Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
MARK(splitAt(isPLNat(x0), y1)) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(snd(snd(x0))) → SNDACTIVE(sndActive(mark(x0)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
U51ACTIVE(tt, 0, y1) → HEADACTIVE(afterNthActive(0, mark(y1)))
U51ACTIVE(tt, y0, 0) → HEADACTIVE(afterNthActive(mark(y0), 0))
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(tail(cons(x0, x1))) → TAILACTIVE(cons(mark(x0), x1))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(snd(and(x0, x1))) → SNDACTIVE(andActive(mark(x0), x1))
MARK(snd(sel(x0, x1))) → SNDACTIVE(selActive(mark(x0), mark(x1)))
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(tail(0)) → TAILACTIVE(0)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
U51ACTIVE(tt, tail(x0), y1) → HEADACTIVE(afterNthActive(tailActive(mark(x0)), mark(y1)))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(tail(isPLNat(x0))) → TAILACTIVE(isPLNatActive(x0))
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(snd(U91(x0, x1))) → SNDACTIVE(U91Active(mark(x0), x1))
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, snd(x0)) → HEADACTIVE(afterNthActive(mark(y0), sndActive(mark(x0))))
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, snd(x0), y1) → HEADACTIVE(afterNthActive(sndActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, natsFrom(x0), y1) → HEADACTIVE(afterNthActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
U51ACTIVE(tt, take(x0, x1), y1) → HEADACTIVE(afterNthActive(takeActive(mark(x0), mark(x1)), mark(y1)))
U51ACTIVE(tt, y0, s(x0)) → HEADACTIVE(afterNthActive(mark(y0), s(mark(x0))))
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
U51ACTIVE(tt, nil, y1) → HEADACTIVE(afterNthActive(nil, mark(y1)))
U51ACTIVE(tt, y0, nil) → HEADACTIVE(afterNthActive(mark(y0), nil))
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(snd(U82(x0, x1))) → SNDACTIVE(U82Active(mark(x0), x1))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U51ACTIVE(tt, y0, and(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), andActive(mark(x0), x1)))
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
U51ACTIVE(tt, U101(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(snd(pair(x0, x1))) → SNDACTIVE(pair(mark(x0), mark(x1)))
U51ACTIVE(tt, y0, tail(x0)) → HEADACTIVE(afterNthActive(mark(y0), tailActive(mark(x0))))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
MARK(tail(U82(x0, x1))) → TAILACTIVE(U82Active(mark(x0), x1))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, afterNth(x0, x1), y1) → HEADACTIVE(afterNthActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(snd(isPLNat(x0))) → SNDACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(snd(head(x0))) → SNDACTIVE(headActive(mark(x0)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(take(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U51ACTIVE(tt, y0, U21(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U21Active(mark(x0), x1)))
MARK(splitAt(U61(x0, x1), y1)) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(snd(U21(x0, x1))) → SNDACTIVE(U21Active(mark(x0), x1))
U51ACTIVE(tt, U21(x0, x1), y1) → HEADACTIVE(afterNthActive(U21Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
ISPLNATACTIVE(splitAt(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(snd(U31(x0, x1))) → SNDACTIVE(U31Active(mark(x0), x1))
U51ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → HEADACTIVE(afterNthActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U91ACTIVE(tt, XS) → MARK(XS)
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
U51ACTIVE(tt, y0, splitAt(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
U51ACTIVE(tt, y0, U82(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(tail(U31(x0, x1))) → TAILACTIVE(U31Active(mark(x0), x1))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
U51ACTIVE(tt, y0, natsFrom(x0)) → HEADACTIVE(afterNthActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, y0, isNatural(x0)) → HEADACTIVE(afterNthActive(mark(y0), isNaturalActive(x0)))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → MARK(XS)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(splitAt(U11(x0, x1, x2), y1)) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(splitAt(sel(x0, x1), y1)) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
U51ACTIVE(tt, y0, pair(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(tail(fst(x0))) → TAILACTIVE(fstActive(mark(x0)))
U51ACTIVE(tt, and(x0, x1), y1) → HEADACTIVE(afterNthActive(andActive(mark(x0), x1), mark(y1)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
U51ACTIVE(tt, isPLNat(x0), y1) → HEADACTIVE(afterNthActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, U71(x0, x1), y1) → HEADACTIVE(afterNthActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, y1) → HEADACTIVE(U11Active(andActive(isNaturalActive(mark(y0)), isLNat(mark(y1))), mark(y0), mark(y1)))
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(take(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(tail(splitAt(x0, x1))) → TAILACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
U51ACTIVE(tt, isLNat(x0), y1) → HEADACTIVE(afterNthActive(isLNatActive(x0), mark(y1)))
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(tail(pair(x0, x1))) → TAILACTIVE(pair(mark(x0), mark(x1)))
U51ACTIVE(tt, fst(x0), y1) → HEADACTIVE(afterNthActive(fstActive(mark(x0)), mark(y1)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(tail(U61(x0, x1))) → TAILACTIVE(U61Active(mark(x0), x1))
MARK(snd(splitAt(x0, x1))) → SNDACTIVE(splitAtActive(mark(x0), mark(x1)))
ISLNATACTIVE(take(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, y0, sel(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
U51ACTIVE(tt, U81(x0, x1, x2, x3), y1) → HEADACTIVE(afterNthActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
ISPLNATACTIVE(splitAt(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
U51ACTIVE(tt, y0, take(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, U11(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U11Active(mark(x0), x1, x2), mark(y1)))
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(tail(U41(x0, x1))) → TAILACTIVE(U41Active(mark(x0), x1))
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(splitAt(splitAt(x0, x1), y1)) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(snd(U81(x0, x1, x2, x3))) → SNDACTIVE(U81Active(mark(x0), x1, x2, x3))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U51ACTIVE(tt, U61(x0, x1), y1) → HEADACTIVE(afterNthActive(U61Active(mark(x0), x1), mark(y1)))
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(splitAt(snd(x0), y1)) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(tail(U81(x0, x1, x2, x3))) → TAILACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U31(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U31Active(mark(x0), x1)))
MARK(snd(take(x0, x1))) → SNDACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(splitAt(U21(x0, x1), y1)) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(splitAt(U81(x0, x1, x2, x3), y1)) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U51ACTIVE(tt, isNatural(x0), y1) → HEADACTIVE(afterNthActive(isNaturalActive(x0), mark(y1)))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(snd(U51(x0, x1, x2))) → SNDACTIVE(U51Active(mark(x0), x1, x2))
MARK(splitAt(take(x0, x1), y1)) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(snd(tail(x0))) → SNDACTIVE(tailActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(tail(sel(x0, x1))) → TAILACTIVE(selActive(mark(x0), mark(x1)))
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(splitAt(tail(x0), y1)) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
U51ACTIVE(tt, U31(x0, x1), y1) → HEADACTIVE(afterNthActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(snd(natsFrom(x0))) → SNDACTIVE(natsFromActive(mark(x0)))
MARK(U91(x1, x2)) → MARK(x1)
MARK(tail(U11(x0, x1, x2))) → TAILACTIVE(U11Active(mark(x0), x1, x2))
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U51ACTIVE(tt, y0, afterNth(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, y0, fst(x0)) → HEADACTIVE(afterNthActive(mark(y0), fstActive(mark(x0))))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
ISPLNATACTIVE(splitAt(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(splitAt(U41(x0, x1), y1)) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(snd(isLNat(x0))) → SNDACTIVE(isLNatActive(x0))
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(tail(U71(x0, x1))) → TAILACTIVE(U71Active(mark(x0), x1))
MARK(splitAt(s(x0), y1)) → SPLITATACTIVE(s(mark(x0)), mark(y1))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(splitAt(afterNth(x0, x1), y1)) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(snd(U11(x0, x1, x2))) → SNDACTIVE(U11Active(mark(x0), x1, x2))
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(tail(U51(x0, x1, x2))) → TAILACTIVE(U51Active(mark(x0), x1, x2))
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
AFTERNTHACTIVE(head(x0), y1) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(splitAt(isNatural(x0), y1)) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(splitAt(head(x0), y1)) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
U51ACTIVE(tt, tt, y1) → HEADACTIVE(afterNthActive(tt, mark(y1)))
U51ACTIVE(tt, y0, tt) → HEADACTIVE(afterNthActive(mark(y0), tt))
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(snd(U41(x0, x1))) → SNDACTIVE(U41Active(mark(x0), x1))
MARK(tail(afterNth(x0, x1))) → TAILACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(tail(isLNat(x0))) → TAILACTIVE(isLNatActive(x0))
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
AFTERNTHACTIVE(0, y1) → ANDACTIVE(tt, isLNat(y1))
MARK(and(x1, x2)) → MARK(x1)
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U51ACTIVE(tt, y0, U41(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U41Active(mark(x0), x1)))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
AFTERNTHACTIVE(s(x0), y1) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(splitAt(natsFrom(x0), y1)) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, U91(x0, x1), y1) → HEADACTIVE(afterNthActive(U91Active(mark(x0), x1), mark(y1)))
U51ACTIVE(tt, y0, U51(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(tail(U101(x0, x1, x2))) → TAILACTIVE(U101Active(mark(x0), x1, x2))
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(tail(snd(x0))) → TAILACTIVE(sndActive(mark(x0)))
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U61(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U61Active(mark(x0), x1)))
ISLNATACTIVE(take(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(splitAt(fst(x0), y1)) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
AFTERNTHACTIVE(sel(x0, x1), y1) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U51ACTIVE(tt, y0, isLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isLNatActive(x0)))
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
MARK(snd(fst(x0))) → SNDACTIVE(fstActive(mark(x0)))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(tail(tt)) → TAILACTIVE(tt)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
U51ACTIVE(tt, U41(x0, x1), y1) → HEADACTIVE(afterNthActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(tail(isNatural(x0))) → TAILACTIVE(isNaturalActive(x0))
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(splitAt(isLNat(x0), y1)) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U51ACTIVE(tt, y0, cons(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
U51ACTIVE(tt, splitAt(x0, x1), y1) → HEADACTIVE(afterNthActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(splitAt(U71(x0, x1), y1)) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
U51ACTIVE(tt, head(x0), y1) → HEADACTIVE(afterNthActive(headActive(mark(x0)), mark(y1)))
MARK(snd(afterNth(x0, x1))) → SNDACTIVE(afterNthActive(mark(x0), mark(x1)))
U51ACTIVE(tt, cons(x0, x1), y1) → HEADACTIVE(afterNthActive(cons(mark(x0), x1), mark(y1)))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(natsFrom(x0))) → TAILACTIVE(natsFromActive(mark(x0)))
U51ACTIVE(tt, y0, isPLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isPLNatActive(x0)))
U51ACTIVE(tt, y0, U11(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U11Active(mark(x0), x1, x2)))
U31ACTIVE(tt, N) → MARK(N)
MARK(splitAt(U31(x0, x1), y1)) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(tail(U21(x0, x1))) → TAILACTIVE(U21Active(mark(x0), x1))
MARK(splitAt(U51(x0, x1, x2), y1)) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, y0, U71(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U71Active(mark(x0), x1)))
U51ACTIVE(tt, pair(x0, x1), y1) → HEADACTIVE(afterNthActive(pair(mark(x0), mark(x1)), mark(y1)))
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
MARK(splitAt(and(x0, x1), y1)) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, sel(x0, x1), y1) → HEADACTIVE(afterNthActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
ISPLNATACTIVE(splitAt(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(tail(head(x0))) → TAILACTIVE(headActive(mark(x0)))
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 5 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(tail(take(x0, x1))) → TAILACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(tail(and(x0, x1))) → TAILACTIVE(andActive(mark(x0), x1))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(snd(U71(x0, x1))) → SNDACTIVE(U71Active(mark(x0), x1))
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(splitAt(U82(x0, x1), y1)) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(splitAt(U101(x0, x1, x2), y1)) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
MARK(tail(U91(x0, x1))) → TAILACTIVE(U91Active(mark(x0), x1))
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
U51ACTIVE(tt, U51(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(snd(isNatural(x0))) → SNDACTIVE(isNaturalActive(x0))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(splitAt(U91(x0, x1), y1)) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(snd(U101(x0, x1, x2))) → SNDACTIVE(U101Active(mark(x0), x1, x2))
U51ACTIVE(tt, y0, U101(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U101Active(mark(x0), x1, x2)))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(snd(U61(x0, x1))) → SNDACTIVE(U61Active(mark(x0), x1))
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U51ACTIVE(tt, y0, head(x0)) → HEADACTIVE(afterNthActive(mark(y0), headActive(mark(x0))))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(splitAt(0, y1)) → SPLITATACTIVE(0, mark(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
U51ACTIVE(tt, y0, U91(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U91Active(mark(x0), x1)))
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
U51ACTIVE(tt, s(x0), y1) → HEADACTIVE(afterNthActive(s(mark(x0)), mark(y1)))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(tail(tail(x0))) → TAILACTIVE(tailActive(mark(x0)))
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U51ACTIVE(tt, U82(x0, x1), y1) → HEADACTIVE(afterNthActive(U82Active(mark(x0), x1), mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(splitAt(isPLNat(x0), y1)) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS)))
MARK(snd(snd(x0))) → SNDACTIVE(sndActive(mark(x0)))
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
U51ACTIVE(tt, y0, 0) → HEADACTIVE(afterNthActive(mark(y0), 0))
U51ACTIVE(tt, 0, y1) → HEADACTIVE(afterNthActive(0, mark(y1)))
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(tail(cons(x0, x1))) → TAILACTIVE(cons(mark(x0), x1))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(snd(and(x0, x1))) → SNDACTIVE(andActive(mark(x0), x1))
MARK(snd(sel(x0, x1))) → SNDACTIVE(selActive(mark(x0), mark(x1)))
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U51ACTIVE(tt, tail(x0), y1) → HEADACTIVE(afterNthActive(tailActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(tail(isPLNat(x0))) → TAILACTIVE(isPLNatActive(x0))
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(snd(U91(x0, x1))) → SNDACTIVE(U91Active(mark(x0), x1))
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, snd(x0)) → HEADACTIVE(afterNthActive(mark(y0), sndActive(mark(x0))))
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, snd(x0), y1) → HEADACTIVE(afterNthActive(sndActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, natsFrom(x0), y1) → HEADACTIVE(afterNthActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, y0, s(x0)) → HEADACTIVE(afterNthActive(mark(y0), s(mark(x0))))
U51ACTIVE(tt, take(x0, x1), y1) → HEADACTIVE(afterNthActive(takeActive(mark(x0), mark(x1)), mark(y1)))
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, y0, nil) → HEADACTIVE(afterNthActive(mark(y0), nil))
U51ACTIVE(tt, nil, y1) → HEADACTIVE(afterNthActive(nil, mark(y1)))
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(snd(U82(x0, x1))) → SNDACTIVE(U82Active(mark(x0), x1))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
U51ACTIVE(tt, y0, and(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), andActive(mark(x0), x1)))
U51ACTIVE(tt, U101(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(snd(pair(x0, x1))) → SNDACTIVE(pair(mark(x0), mark(x1)))
U51ACTIVE(tt, y0, tail(x0)) → HEADACTIVE(afterNthActive(mark(y0), tailActive(mark(x0))))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
MARK(tail(U82(x0, x1))) → TAILACTIVE(U82Active(mark(x0), x1))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, afterNth(x0, x1), y1) → HEADACTIVE(afterNthActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
MARK(snd(isPLNat(x0))) → SNDACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(snd(head(x0))) → SNDACTIVE(headActive(mark(x0)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
ISLNATACTIVE(take(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U51ACTIVE(tt, y0, U21(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U21Active(mark(x0), x1)))
MARK(splitAt(U61(x0, x1), y1)) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(snd(U21(x0, x1))) → SNDACTIVE(U21Active(mark(x0), x1))
U51ACTIVE(tt, U21(x0, x1), y1) → HEADACTIVE(afterNthActive(U21Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
ISPLNATACTIVE(splitAt(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(snd(U31(x0, x1))) → SNDACTIVE(U31Active(mark(x0), x1))
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → HEADACTIVE(afterNthActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U91ACTIVE(tt, XS) → MARK(XS)
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
U51ACTIVE(tt, y0, splitAt(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U82(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U21(x1, x2)) → MARK(x1)
MARK(tail(U31(x0, x1))) → TAILACTIVE(U31Active(mark(x0), x1))
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, y0, natsFrom(x0)) → HEADACTIVE(afterNthActive(mark(y0), natsFromActive(mark(x0))))
U51ACTIVE(tt, y0, isNatural(x0)) → HEADACTIVE(afterNthActive(mark(y0), isNaturalActive(x0)))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(splitAt(U11(x0, x1, x2), y1)) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(splitAt(sel(x0, x1), y1)) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
U51ACTIVE(tt, y0, pair(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(tail(fst(x0))) → TAILACTIVE(fstActive(mark(x0)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U51ACTIVE(tt, and(x0, x1), y1) → HEADACTIVE(afterNthActive(andActive(mark(x0), x1), mark(y1)))
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(snd(x1)) → MARK(x1)
U51ACTIVE(tt, isPLNat(x0), y1) → HEADACTIVE(afterNthActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, U71(x0, x1), y1) → HEADACTIVE(afterNthActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, y1) → HEADACTIVE(U11Active(andActive(isNaturalActive(mark(y0)), isLNat(mark(y1))), mark(y0), mark(y1)))
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(take(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(tail(splitAt(x0, x1))) → TAILACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
U51ACTIVE(tt, isLNat(x0), y1) → HEADACTIVE(afterNthActive(isLNatActive(x0), mark(y1)))
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U51ACTIVE(tt, fst(x0), y1) → HEADACTIVE(afterNthActive(fstActive(mark(x0)), mark(y1)))
MARK(tail(U61(x0, x1))) → TAILACTIVE(U61Active(mark(x0), x1))
MARK(snd(splitAt(x0, x1))) → SNDACTIVE(splitAtActive(mark(x0), mark(x1)))
ISLNATACTIVE(take(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, y0, sel(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
ISPLNATACTIVE(splitAt(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U51ACTIVE(tt, U81(x0, x1, x2, x3), y1) → HEADACTIVE(afterNthActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, take(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, U11(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U11Active(mark(x0), x1, x2), mark(y1)))
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(tail(U41(x0, x1))) → TAILACTIVE(U41Active(mark(x0), x1))
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(splitAt(splitAt(x0, x1), y1)) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(snd(U81(x0, x1, x2, x3))) → SNDACTIVE(U81Active(mark(x0), x1, x2, x3))
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
U51ACTIVE(tt, U61(x0, x1), y1) → HEADACTIVE(afterNthActive(U61Active(mark(x0), x1), mark(y1)))
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(splitAt(snd(x0), y1)) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(tail(U81(x0, x1, x2, x3))) → TAILACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(snd(take(x0, x1))) → SNDACTIVE(takeActive(mark(x0), mark(x1)))
U51ACTIVE(tt, y0, U31(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(splitAt(U21(x0, x1), y1)) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(splitAt(U81(x0, x1, x2, x3), y1)) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U51ACTIVE(tt, isNatural(x0), y1) → HEADACTIVE(afterNthActive(isNaturalActive(x0), mark(y1)))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(snd(U51(x0, x1, x2))) → SNDACTIVE(U51Active(mark(x0), x1, x2))
MARK(splitAt(take(x0, x1), y1)) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(snd(tail(x0))) → SNDACTIVE(tailActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(tail(sel(x0, x1))) → TAILACTIVE(selActive(mark(x0), mark(x1)))
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(splitAt(tail(x0), y1)) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U51ACTIVE(tt, U31(x0, x1), y1) → HEADACTIVE(afterNthActive(U31Active(mark(x0), x1), mark(y1)))
MARK(snd(natsFrom(x0))) → SNDACTIVE(natsFromActive(mark(x0)))
MARK(U91(x1, x2)) → MARK(x1)
MARK(tail(U11(x0, x1, x2))) → TAILACTIVE(U11Active(mark(x0), x1, x2))
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U51ACTIVE(tt, y0, afterNth(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, y0, fst(x0)) → HEADACTIVE(afterNthActive(mark(y0), fstActive(mark(x0))))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
ISPLNATACTIVE(splitAt(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(splitAt(U41(x0, x1), y1)) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(snd(isLNat(x0))) → SNDACTIVE(isLNatActive(x0))
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(tail(U71(x0, x1))) → TAILACTIVE(U71Active(mark(x0), x1))
MARK(splitAt(s(x0), y1)) → SPLITATACTIVE(s(mark(x0)), mark(y1))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(splitAt(afterNth(x0, x1), y1)) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(snd(U11(x0, x1, x2))) → SNDACTIVE(U11Active(mark(x0), x1, x2))
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(tail(U51(x0, x1, x2))) → TAILACTIVE(U51Active(mark(x0), x1, x2))
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
AFTERNTHACTIVE(head(x0), y1) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(splitAt(isNatural(x0), y1)) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(splitAt(head(x0), y1)) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
U51ACTIVE(tt, y0, tt) → HEADACTIVE(afterNthActive(mark(y0), tt))
U51ACTIVE(tt, tt, y1) → HEADACTIVE(afterNthActive(tt, mark(y1)))
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(snd(U41(x0, x1))) → SNDACTIVE(U41Active(mark(x0), x1))
MARK(tail(afterNth(x0, x1))) → TAILACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(tail(isLNat(x0))) → TAILACTIVE(isLNatActive(x0))
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
AFTERNTHACTIVE(0, y1) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U51ACTIVE(tt, y0, U41(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U41Active(mark(x0), x1)))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(splitAt(natsFrom(x0), y1)) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
AFTERNTHACTIVE(s(x0), y1) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U51(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U51Active(mark(x0), x1, x2)))
U51ACTIVE(tt, U91(x0, x1), y1) → HEADACTIVE(afterNthActive(U91Active(mark(x0), x1), mark(y1)))
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(tail(U101(x0, x1, x2))) → TAILACTIVE(U101Active(mark(x0), x1, x2))
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(tail(snd(x0))) → TAILACTIVE(sndActive(mark(x0)))
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(take(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U51ACTIVE(tt, y0, U61(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(splitAt(fst(x0), y1)) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
AFTERNTHACTIVE(sel(x0, x1), y1) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, y0, isLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isLNatActive(x0)))
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(snd(fst(x0))) → SNDACTIVE(fstActive(mark(x0)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
U51ACTIVE(tt, U41(x0, x1), y1) → HEADACTIVE(afterNthActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(tail(isNatural(x0))) → TAILACTIVE(isNaturalActive(x0))
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(splitAt(isLNat(x0), y1)) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, cons(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
U51ACTIVE(tt, splitAt(x0, x1), y1) → HEADACTIVE(afterNthActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(splitAt(U71(x0, x1), y1)) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(snd(afterNth(x0, x1))) → SNDACTIVE(afterNthActive(mark(x0), mark(x1)))
U51ACTIVE(tt, head(x0), y1) → HEADACTIVE(afterNthActive(headActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, cons(x0, x1), y1) → HEADACTIVE(afterNthActive(cons(mark(x0), x1), mark(y1)))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(natsFrom(x0))) → TAILACTIVE(natsFromActive(mark(x0)))
U51ACTIVE(tt, y0, isPLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isPLNatActive(x0)))
U51ACTIVE(tt, y0, U11(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U11Active(mark(x0), x1, x2)))
U31ACTIVE(tt, N) → MARK(N)
MARK(splitAt(U31(x0, x1), y1)) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(tail(U21(x0, x1))) → TAILACTIVE(U21Active(mark(x0), x1))
MARK(splitAt(U51(x0, x1, x2), y1)) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, y0, U71(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U71Active(mark(x0), x1)))
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U51ACTIVE(tt, pair(x0, x1), y1) → HEADACTIVE(afterNthActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(splitAt(and(x0, x1), y1)) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, sel(x0, x1), y1) → HEADACTIVE(afterNthActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
ISPLNATACTIVE(splitAt(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(tail(head(x0))) → TAILACTIVE(headActive(mark(x0)))
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule U101ACTIVE(tt, N, XS) → FSTACTIVE(splitAtActive(mark(N), mark(XS))) at position [0] we obtained the following new rules:

U101ACTIVE(tt, natsFrom(x0), y1) → FSTACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
U101ACTIVE(tt, y0, snd(x0)) → FSTACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U101ACTIVE(tt, y0, U31(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
U101ACTIVE(tt, y0, U51(x0, x1, x2)) → FSTACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
U101ACTIVE(tt, y0, s(x0)) → FSTACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U101ACTIVE(tt, y0, 0) → FSTACTIVE(splitAtActive(mark(y0), 0))
U101ACTIVE(tt, 0, y1) → FSTACTIVE(splitAtActive(0, mark(y1)))
U101ACTIVE(tt, y0, cons(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U101ACTIVE(tt, U11(x0, x1, x2), y1) → FSTACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
U101ACTIVE(tt, s(x0), y1) → FSTACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
U101ACTIVE(tt, y0, U91(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U101ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → FSTACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U101ACTIVE(tt, y0, U71(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
U101ACTIVE(tt, snd(x0), y1) → FSTACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
U101ACTIVE(tt, y0, tail(x0)) → FSTACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
U101ACTIVE(tt, y0, U61(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U101ACTIVE(tt, y0, U82(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
U101ACTIVE(tt, U51(x0, x1, x2), y1) → FSTACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
U101ACTIVE(tt, U61(x0, x1), y1) → FSTACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, U101(x0, x1, x2), y1) → FSTACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
U101ACTIVE(tt, y0, isNatural(x0)) → FSTACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
U101ACTIVE(tt, and(x0, x1), y1) → FSTACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, y0, fst(x0)) → FSTACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
U101ACTIVE(tt, y0, take(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U101ACTIVE(tt, take(x0, x1), y1) → FSTACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
U101ACTIVE(tt, y0, nil) → FSTACTIVE(splitAtActive(mark(y0), nil))
U101ACTIVE(tt, nil, y1) → FSTACTIVE(splitAtActive(nil, mark(y1)))
U101ACTIVE(tt, tail(x0), y1) → FSTACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
U101ACTIVE(tt, U21(x0, x1), y1) → FSTACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, afterNth(x0, x1), y1) → FSTACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U101ACTIVE(tt, y0, pair(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U101ACTIVE(tt, isNatural(x0), y1) → FSTACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
U101ACTIVE(tt, y0, tt) → FSTACTIVE(splitAtActive(mark(y0), tt))
U101ACTIVE(tt, tt, y1) → FSTACTIVE(splitAtActive(tt, mark(y1)))
U101ACTIVE(tt, y0, afterNth(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
U101ACTIVE(tt, y0, splitAt(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
U101ACTIVE(tt, U71(x0, x1), y1) → FSTACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, fst(x0), y1) → FSTACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
U101ACTIVE(tt, y0, isLNat(x0)) → FSTACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
U101ACTIVE(tt, U91(x0, x1), y1) → FSTACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, y0, U11(x0, x1, x2)) → FSTACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U101ACTIVE(tt, head(x0), y1) → FSTACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
U101ACTIVE(tt, cons(x0, x1), y1) → FSTACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, isLNat(x0), y1) → FSTACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
U101ACTIVE(tt, y0, U101(x0, x1, x2)) → FSTACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
U101ACTIVE(tt, y0, y1) → FSTACTIVE(splitAt(mark(y0), mark(y1)))
U101ACTIVE(tt, y0, isPLNat(x0)) → FSTACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
U101ACTIVE(tt, y0, natsFrom(x0)) → FSTACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U101ACTIVE(tt, pair(x0, x1), y1) → FSTACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
U101ACTIVE(tt, y0, U21(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
U101ACTIVE(tt, U31(x0, x1), y1) → FSTACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, sel(x0, x1), y1) → FSTACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U101ACTIVE(tt, y0, and(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
U101ACTIVE(tt, y0, sel(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
U101ACTIVE(tt, U81(x0, x1, x2, x3), y1) → FSTACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
U101ACTIVE(tt, y0, U41(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U101ACTIVE(tt, isPLNat(x0), y1) → FSTACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
U101ACTIVE(tt, splitAt(x0, x1), y1) → FSTACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
U101ACTIVE(tt, U41(x0, x1), y1) → FSTACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, y0, head(x0)) → FSTACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U101ACTIVE(tt, U82(x0, x1), y1) → FSTACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

U101ACTIVE(tt, natsFrom(x0), y1) → FSTACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(tail(take(x0, x1))) → TAILACTIVE(takeActive(mark(x0), mark(x1)))
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(tail(and(x0, x1))) → TAILACTIVE(andActive(mark(x0), x1))
U101ACTIVE(tt, y0, U91(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(snd(U71(x0, x1))) → SNDACTIVE(U71Active(mark(x0), x1))
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(splitAt(U82(x0, x1), y1)) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
MARK(splitAt(U101(x0, x1, x2), y1)) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
MARK(tail(U91(x0, x1))) → TAILACTIVE(U91Active(mark(x0), x1))
U101ACTIVE(tt, U101(x0, x1, x2), y1) → FSTACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
U51ACTIVE(tt, U51(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(snd(isNatural(x0))) → SNDACTIVE(isNaturalActive(x0))
U101ACTIVE(tt, afterNth(x0, x1), y1) → FSTACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
MARK(snd(U101(x0, x1, x2))) → SNDACTIVE(U101Active(mark(x0), x1, x2))
MARK(splitAt(U91(x0, x1), y1)) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
U101ACTIVE(tt, tt, y1) → FSTACTIVE(splitAtActive(tt, mark(y1)))
U101ACTIVE(tt, y0, tt) → FSTACTIVE(splitAtActive(mark(y0), tt))
U51ACTIVE(tt, y0, U101(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U101Active(mark(x0), x1, x2)))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(snd(U61(x0, x1))) → SNDACTIVE(U61Active(mark(x0), x1))
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U101ACTIVE(tt, y0, U101(x0, x1, x2)) → FSTACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
U51ACTIVE(tt, y0, head(x0)) → HEADACTIVE(afterNthActive(mark(y0), headActive(mark(x0))))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(splitAt(0, y1)) → SPLITATACTIVE(0, mark(y1))
U101ACTIVE(tt, y0, U21(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
U51ACTIVE(tt, y0, U91(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U91Active(mark(x0), x1)))
U101ACTIVE(tt, y0, and(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
U101ACTIVE(tt, U81(x0, x1, x2, x3), y1) → FSTACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U101ACTIVE(tt, isPLNat(x0), y1) → FSTACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
U51ACTIVE(tt, s(x0), y1) → HEADACTIVE(afterNthActive(s(mark(x0)), mark(y1)))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(tail(tail(x0))) → TAILACTIVE(tailActive(mark(x0)))
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U51ACTIVE(tt, U82(x0, x1), y1) → HEADACTIVE(afterNthActive(U82Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
U101ACTIVE(tt, y0, s(x0)) → FSTACTIVE(splitAtActive(mark(y0), s(mark(x0))))
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
MARK(splitAt(isPLNat(x0), y1)) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(snd(snd(x0))) → SNDACTIVE(sndActive(mark(x0)))
U101ACTIVE(tt, snd(x0), y1) → FSTACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
U101ACTIVE(tt, y0, U82(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(x1, x2, x3)) → MARK(x1)
U51ACTIVE(tt, 0, y1) → HEADACTIVE(afterNthActive(0, mark(y1)))
U51ACTIVE(tt, y0, 0) → HEADACTIVE(afterNthActive(mark(y0), 0))
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, U61(x0, x1), y1) → FSTACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(tail(cons(x0, x1))) → TAILACTIVE(cons(mark(x0), x1))
U101ACTIVE(tt, tail(x0), y1) → FSTACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
U101ACTIVE(tt, isNatural(x0), y1) → FSTACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
U101ACTIVE(tt, y0, splitAt(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(snd(and(x0, x1))) → SNDACTIVE(andActive(mark(x0), x1))
MARK(snd(sel(x0, x1))) → SNDACTIVE(selActive(mark(x0), mark(x1)))
U101ACTIVE(tt, U71(x0, x1), y1) → FSTACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
U101ACTIVE(tt, y0, isLNat(x0)) → FSTACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
U51ACTIVE(tt, tail(x0), y1) → HEADACTIVE(afterNthActive(tailActive(mark(x0)), mark(y1)))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
U101ACTIVE(tt, head(x0), y1) → FSTACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(tail(isPLNat(x0))) → TAILACTIVE(isPLNatActive(x0))
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
U101ACTIVE(tt, sel(x0, x1), y1) → FSTACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(snd(U91(x0, x1))) → SNDACTIVE(U91Active(mark(x0), x1))
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, snd(x0)) → HEADACTIVE(afterNthActive(mark(y0), sndActive(mark(x0))))
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U101ACTIVE(tt, 0, y1) → FSTACTIVE(splitAtActive(0, mark(y1)))
U101ACTIVE(tt, y0, 0) → FSTACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, snd(x0), y1) → HEADACTIVE(afterNthActive(sndActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, natsFrom(x0), y1) → HEADACTIVE(afterNthActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
U51ACTIVE(tt, take(x0, x1), y1) → HEADACTIVE(afterNthActive(takeActive(mark(x0), mark(x1)), mark(y1)))
U51ACTIVE(tt, y0, s(x0)) → HEADACTIVE(afterNthActive(mark(y0), s(mark(x0))))
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
U51ACTIVE(tt, nil, y1) → HEADACTIVE(afterNthActive(nil, mark(y1)))
U51ACTIVE(tt, y0, nil) → HEADACTIVE(afterNthActive(mark(y0), nil))
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
U101ACTIVE(tt, take(x0, x1), y1) → FSTACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
MARK(snd(U82(x0, x1))) → SNDACTIVE(U82Active(mark(x0), x1))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U51ACTIVE(tt, y0, and(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), andActive(mark(x0), x1)))
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
U51ACTIVE(tt, U101(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(snd(pair(x0, x1))) → SNDACTIVE(pair(mark(x0), mark(x1)))
U51ACTIVE(tt, y0, tail(x0)) → HEADACTIVE(afterNthActive(mark(y0), tailActive(mark(x0))))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
MARK(tail(U82(x0, x1))) → TAILACTIVE(U82Active(mark(x0), x1))
U51ACTIVE(tt, afterNth(x0, x1), y1) → HEADACTIVE(afterNthActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(snd(isPLNat(x0))) → SNDACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
U101ACTIVE(tt, y0, natsFrom(x0)) → FSTACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
MARK(snd(head(x0))) → SNDACTIVE(headActive(mark(x0)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(take(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U51ACTIVE(tt, y0, U21(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U21Active(mark(x0), x1)))
U101ACTIVE(tt, y0, U41(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
MARK(splitAt(U61(x0, x1), y1)) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
U101ACTIVE(tt, U41(x0, x1), y1) → FSTACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(snd(U21(x0, x1))) → SNDACTIVE(U21Active(mark(x0), x1))
U51ACTIVE(tt, U21(x0, x1), y1) → HEADACTIVE(afterNthActive(U21Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
ISPLNATACTIVE(splitAt(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U101ACTIVE(tt, y0, U51(x0, x1, x2)) → FSTACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(snd(U31(x0, x1))) → SNDACTIVE(U31Active(mark(x0), x1))
U51ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → HEADACTIVE(afterNthActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U91ACTIVE(tt, XS) → MARK(XS)
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
U101ACTIVE(tt, y0, U71(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
U101ACTIVE(tt, U51(x0, x1, x2), y1) → FSTACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
U51ACTIVE(tt, y0, splitAt(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
U51ACTIVE(tt, y0, U82(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(tail(U31(x0, x1))) → TAILACTIVE(U31Active(mark(x0), x1))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
U51ACTIVE(tt, y0, natsFrom(x0)) → HEADACTIVE(afterNthActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, y0, isNatural(x0)) → HEADACTIVE(afterNthActive(mark(y0), isNaturalActive(x0)))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → MARK(XS)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(splitAt(U11(x0, x1, x2), y1)) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(splitAt(sel(x0, x1), y1)) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
U51ACTIVE(tt, y0, pair(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(tail(fst(x0))) → TAILACTIVE(fstActive(mark(x0)))
U51ACTIVE(tt, and(x0, x1), y1) → HEADACTIVE(afterNthActive(andActive(mark(x0), x1), mark(y1)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
U51ACTIVE(tt, isPLNat(x0), y1) → HEADACTIVE(afterNthActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, U71(x0, x1), y1) → HEADACTIVE(afterNthActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, y1) → HEADACTIVE(U11Active(andActive(isNaturalActive(mark(y0)), isLNat(mark(y1))), mark(y0), mark(y1)))
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(take(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(tail(splitAt(x0, x1))) → TAILACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
U51ACTIVE(tt, isLNat(x0), y1) → HEADACTIVE(afterNthActive(isLNatActive(x0), mark(y1)))
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
U51ACTIVE(tt, fst(x0), y1) → HEADACTIVE(afterNthActive(fstActive(mark(x0)), mark(y1)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(snd(splitAt(x0, x1))) → SNDACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(tail(U61(x0, x1))) → TAILACTIVE(U61Active(mark(x0), x1))
ISLNATACTIVE(take(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, y0, sel(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
U51ACTIVE(tt, U81(x0, x1, x2, x3), y1) → HEADACTIVE(afterNthActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
ISPLNATACTIVE(splitAt(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
U51ACTIVE(tt, y0, take(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, and(x0, x1), y1) → FSTACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
U101ACTIVE(tt, y0, fst(x0)) → FSTACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
U101ACTIVE(tt, nil, y1) → FSTACTIVE(splitAtActive(nil, mark(y1)))
U101ACTIVE(tt, y0, nil) → FSTACTIVE(splitAtActive(mark(y0), nil))
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(take(x1, x2)) → MARK(x2)
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
U101ACTIVE(tt, y0, afterNth(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, U11(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U11Active(mark(x0), x1, x2), mark(y1)))
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U101ACTIVE(tt, fst(x0), y1) → FSTACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(tail(U41(x0, x1))) → TAILACTIVE(U41Active(mark(x0), x1))
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(splitAt(splitAt(x0, x1), y1)) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(snd(U81(x0, x1, x2, x3))) → SNDACTIVE(U81Active(mark(x0), x1, x2, x3))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U101ACTIVE(tt, cons(x0, x1), y1) → FSTACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
U51ACTIVE(tt, U61(x0, x1), y1) → HEADACTIVE(afterNthActive(U61Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, isLNat(x0), y1) → FSTACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
U101ACTIVE(tt, pair(x0, x1), y1) → FSTACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(snd(x0), y1)) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(tail(U81(x0, x1, x2, x3))) → TAILACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U101ACTIVE(tt, y0, sel(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U31(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U31Active(mark(x0), x1)))
MARK(snd(take(x0, x1))) → SNDACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
U101ACTIVE(tt, y0, U31(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(splitAt(U21(x0, x1), y1)) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(splitAt(U81(x0, x1, x2, x3), y1)) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U51ACTIVE(tt, isNatural(x0), y1) → HEADACTIVE(afterNthActive(isNaturalActive(x0), mark(y1)))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, U11(x0, x1, x2), y1) → FSTACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(snd(U51(x0, x1, x2))) → SNDACTIVE(U51Active(mark(x0), x1, x2))
MARK(splitAt(take(x0, x1), y1)) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
U101ACTIVE(tt, y0, tail(x0)) → FSTACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(snd(tail(x0))) → SNDACTIVE(tailActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(tail(sel(x0, x1))) → TAILACTIVE(selActive(mark(x0), mark(x1)))
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(splitAt(tail(x0), y1)) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
U51ACTIVE(tt, U31(x0, x1), y1) → HEADACTIVE(afterNthActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(snd(natsFrom(x0))) → SNDACTIVE(natsFromActive(mark(x0)))
MARK(U91(x1, x2)) → MARK(x1)
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(tail(U11(x0, x1, x2))) → TAILACTIVE(U11Active(mark(x0), x1, x2))
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U101ACTIVE(tt, y0, take(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U51ACTIVE(tt, y0, afterNth(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
U101ACTIVE(tt, U21(x0, x1), y1) → FSTACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
U101ACTIVE(tt, y0, y1) → FSTACTIVE(splitAt(mark(y0), mark(y1)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, y0, fst(x0)) → HEADACTIVE(afterNthActive(mark(y0), fstActive(mark(x0))))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
ISPLNATACTIVE(splitAt(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(splitAt(U41(x0, x1), y1)) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(snd(isLNat(x0))) → SNDACTIVE(isLNatActive(x0))
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
U101ACTIVE(tt, y0, head(x0)) → FSTACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
MARK(splitAt(s(x0), y1)) → SPLITATACTIVE(s(mark(x0)), mark(y1))
MARK(tail(U71(x0, x1))) → TAILACTIVE(U71Active(mark(x0), x1))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(splitAt(afterNth(x0, x1), y1)) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
U101ACTIVE(tt, y0, snd(x0)) → FSTACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(snd(U11(x0, x1, x2))) → SNDACTIVE(U11Active(mark(x0), x1, x2))
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(tail(U51(x0, x1, x2))) → TAILACTIVE(U51Active(mark(x0), x1, x2))
U101ACTIVE(tt, s(x0), y1) → FSTACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
AFTERNTHACTIVE(head(x0), y1) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U101ACTIVE(tt, y0, U61(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(splitAt(isNatural(x0), y1)) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(splitAt(head(x0), y1)) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
U51ACTIVE(tt, tt, y1) → HEADACTIVE(afterNthActive(tt, mark(y1)))
U51ACTIVE(tt, y0, tt) → HEADACTIVE(afterNthActive(mark(y0), tt))
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(snd(U41(x0, x1))) → SNDACTIVE(U41Active(mark(x0), x1))
MARK(tail(afterNth(x0, x1))) → TAILACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(tail(isLNat(x0))) → TAILACTIVE(isLNatActive(x0))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
U101ACTIVE(tt, U91(x0, x1), y1) → FSTACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
AFTERNTHACTIVE(0, y1) → ANDACTIVE(tt, isLNat(y1))
MARK(and(x1, x2)) → MARK(x1)
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, U31(x0, x1), y1) → FSTACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U51ACTIVE(tt, y0, U41(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U41Active(mark(x0), x1)))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(U61(x1, x2)) → MARK(x1)
AFTERNTHACTIVE(s(x0), y1) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(splitAt(natsFrom(x0), y1)) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
U101ACTIVE(tt, splitAt(x0, x1), y1) → FSTACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
U51ACTIVE(tt, U91(x0, x1), y1) → HEADACTIVE(afterNthActive(U91Active(mark(x0), x1), mark(y1)))
U51ACTIVE(tt, y0, U51(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
U101ACTIVE(tt, U82(x0, x1), y1) → FSTACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(tail(U101(x0, x1, x2))) → TAILACTIVE(U101Active(mark(x0), x1, x2))
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
MARK(tail(snd(x0))) → TAILACTIVE(sndActive(mark(x0)))
U101ACTIVE(tt, y0, cons(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U51ACTIVE(tt, y0, U61(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U61Active(mark(x0), x1)))
ISLNATACTIVE(take(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(splitAt(fst(x0), y1)) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
AFTERNTHACTIVE(sel(x0, x1), y1) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U101ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → FSTACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U51ACTIVE(tt, y0, isLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isLNatActive(x0)))
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
MARK(snd(fst(x0))) → SNDACTIVE(fstActive(mark(x0)))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
U51ACTIVE(tt, U41(x0, x1), y1) → HEADACTIVE(afterNthActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(tail(isNatural(x0))) → TAILACTIVE(isNaturalActive(x0))
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(splitAt(isLNat(x0), y1)) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U101ACTIVE(tt, y0, isNatural(x0)) → FSTACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U51ACTIVE(tt, y0, cons(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
U51ACTIVE(tt, splitAt(x0, x1), y1) → HEADACTIVE(afterNthActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
U101ACTIVE(tt, y0, pair(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(splitAt(U71(x0, x1), y1)) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
U51ACTIVE(tt, head(x0), y1) → HEADACTIVE(afterNthActive(headActive(mark(x0)), mark(y1)))
MARK(snd(afterNth(x0, x1))) → SNDACTIVE(afterNthActive(mark(x0), mark(x1)))
U51ACTIVE(tt, cons(x0, x1), y1) → HEADACTIVE(afterNthActive(cons(mark(x0), x1), mark(y1)))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U51ACTIVE(tt, y0, isPLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isPLNatActive(x0)))
MARK(tail(natsFrom(x0))) → TAILACTIVE(natsFromActive(mark(x0)))
U51ACTIVE(tt, y0, U11(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U11Active(mark(x0), x1, x2)))
U101ACTIVE(tt, y0, U11(x0, x1, x2)) → FSTACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U31ACTIVE(tt, N) → MARK(N)
MARK(splitAt(U31(x0, x1), y1)) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(splitAt(U51(x0, x1, x2), y1)) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(tail(U21(x0, x1))) → TAILACTIVE(U21Active(mark(x0), x1))
U101ACTIVE(tt, y0, isPLNat(x0)) → FSTACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, y0, U71(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U71Active(mark(x0), x1)))
U51ACTIVE(tt, pair(x0, x1), y1) → HEADACTIVE(afterNthActive(pair(mark(x0), mark(x1)), mark(y1)))
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
MARK(splitAt(and(x0, x1), y1)) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, sel(x0, x1), y1) → HEADACTIVE(afterNthActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
ISPLNATACTIVE(splitAt(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
U41ACTIVE(tt, N) → MARK(N)
MARK(tail(head(x0))) → TAILACTIVE(headActive(mark(x0)))

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

U101ACTIVE(tt, natsFrom(x0), y1) → FSTACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(tail(take(x0, x1))) → TAILACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(tail(and(x0, x1))) → TAILACTIVE(andActive(mark(x0), x1))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
U101ACTIVE(tt, y0, U91(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(snd(U71(x0, x1))) → SNDACTIVE(U71Active(mark(x0), x1))
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(splitAt(U82(x0, x1), y1)) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(splitAt(U101(x0, x1, x2), y1)) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
MARK(tail(U91(x0, x1))) → TAILACTIVE(U91Active(mark(x0), x1))
U101ACTIVE(tt, U101(x0, x1, x2), y1) → FSTACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
U51ACTIVE(tt, U51(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U41(x1, x2)) → MARK(x1)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(snd(isNatural(x0))) → SNDACTIVE(isNaturalActive(x0))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
U101ACTIVE(tt, afterNth(x0, x1), y1) → FSTACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
MARK(splitAt(U91(x0, x1), y1)) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(snd(U101(x0, x1, x2))) → SNDACTIVE(U101Active(mark(x0), x1, x2))
U51ACTIVE(tt, y0, U101(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U101Active(mark(x0), x1, x2)))
U101ACTIVE(tt, tt, y1) → FSTACTIVE(splitAtActive(tt, mark(y1)))
U101ACTIVE(tt, y0, tt) → FSTACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
ANDACTIVE(tt, X) → MARK(X)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(snd(U61(x0, x1))) → SNDACTIVE(U61Active(mark(x0), x1))
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U101ACTIVE(tt, y0, U101(x0, x1, x2)) → FSTACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
U51ACTIVE(tt, y0, head(x0)) → HEADACTIVE(afterNthActive(mark(y0), headActive(mark(x0))))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(splitAt(0, y1)) → SPLITATACTIVE(0, mark(y1))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
U101ACTIVE(tt, y0, U21(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
U51ACTIVE(tt, y0, U91(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U91Active(mark(x0), x1)))
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U101ACTIVE(tt, y0, and(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
MARK(U71(x1, x2)) → MARK(x1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
U101ACTIVE(tt, U81(x0, x1, x2, x3), y1) → FSTACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U101ACTIVE(tt, isPLNat(x0), y1) → FSTACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
U51ACTIVE(tt, s(x0), y1) → HEADACTIVE(afterNthActive(s(mark(x0)), mark(y1)))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(tail(tail(x0))) → TAILACTIVE(tailActive(mark(x0)))
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U51ACTIVE(tt, U82(x0, x1), y1) → HEADACTIVE(afterNthActive(U82Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
U101ACTIVE(tt, y0, s(x0)) → FSTACTIVE(splitAtActive(mark(y0), s(mark(x0))))
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, N, XS) → MARK(N)
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(splitAt(isPLNat(x0), y1)) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
MARK(snd(snd(x0))) → SNDACTIVE(sndActive(mark(x0)))
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
U101ACTIVE(tt, snd(x0), y1) → FSTACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
U101ACTIVE(tt, y0, U82(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(x1, x2, x3)) → MARK(x1)
U51ACTIVE(tt, 0, y1) → HEADACTIVE(afterNthActive(0, mark(y1)))
U51ACTIVE(tt, y0, 0) → HEADACTIVE(afterNthActive(mark(y0), 0))
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, U61(x0, x1), y1) → FSTACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
MARK(tail(cons(x0, x1))) → TAILACTIVE(cons(mark(x0), x1))
U101ACTIVE(tt, tail(x0), y1) → FSTACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
U101ACTIVE(tt, isNatural(x0), y1) → FSTACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(snd(and(x0, x1))) → SNDACTIVE(andActive(mark(x0), x1))
U101ACTIVE(tt, y0, splitAt(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(snd(sel(x0, x1))) → SNDACTIVE(selActive(mark(x0), mark(x1)))
U101ACTIVE(tt, U71(x0, x1), y1) → FSTACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
U101ACTIVE(tt, y0, isLNat(x0)) → FSTACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U51ACTIVE(tt, tail(x0), y1) → HEADACTIVE(afterNthActive(tailActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
U101ACTIVE(tt, head(x0), y1) → FSTACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(tail(isPLNat(x0))) → TAILACTIVE(isPLNatActive(x0))
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
U101ACTIVE(tt, sel(x0, x1), y1) → FSTACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(snd(U91(x0, x1))) → SNDACTIVE(U91Active(mark(x0), x1))
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, snd(x0)) → HEADACTIVE(afterNthActive(mark(y0), sndActive(mark(x0))))
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U101ACTIVE(tt, 0, y1) → FSTACTIVE(splitAtActive(0, mark(y1)))
U101ACTIVE(tt, y0, 0) → FSTACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, snd(x0), y1) → HEADACTIVE(afterNthActive(sndActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, natsFrom(x0), y1) → HEADACTIVE(afterNthActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
U51ACTIVE(tt, take(x0, x1), y1) → HEADACTIVE(afterNthActive(takeActive(mark(x0), mark(x1)), mark(y1)))
U51ACTIVE(tt, y0, s(x0)) → HEADACTIVE(afterNthActive(mark(y0), s(mark(x0))))
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, nil, y1) → HEADACTIVE(afterNthActive(nil, mark(y1)))
U51ACTIVE(tt, y0, nil) → HEADACTIVE(afterNthActive(mark(y0), nil))
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(snd(U82(x0, x1))) → SNDACTIVE(U82Active(mark(x0), x1))
U101ACTIVE(tt, take(x0, x1), y1) → FSTACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U51ACTIVE(tt, y0, and(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), andActive(mark(x0), x1)))
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
U51ACTIVE(tt, U101(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(snd(pair(x0, x1))) → SNDACTIVE(pair(mark(x0), mark(x1)))
U51ACTIVE(tt, y0, tail(x0)) → HEADACTIVE(afterNthActive(mark(y0), tailActive(mark(x0))))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
MARK(tail(U82(x0, x1))) → TAILACTIVE(U82Active(mark(x0), x1))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, afterNth(x0, x1), y1) → HEADACTIVE(afterNthActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
MARK(snd(isPLNat(x0))) → SNDACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
U101ACTIVE(tt, y0, natsFrom(x0)) → FSTACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
MARK(snd(head(x0))) → SNDACTIVE(headActive(mark(x0)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(take(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
U51ACTIVE(tt, y0, U21(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U21Active(mark(x0), x1)))
U101ACTIVE(tt, y0, U41(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
MARK(splitAt(U61(x0, x1), y1)) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(snd(U21(x0, x1))) → SNDACTIVE(U21Active(mark(x0), x1))
U101ACTIVE(tt, U41(x0, x1), y1) → FSTACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
U51ACTIVE(tt, U21(x0, x1), y1) → HEADACTIVE(afterNthActive(U21Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
ISPLNATACTIVE(splitAt(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(snd(U31(x0, x1))) → SNDACTIVE(U31Active(mark(x0), x1))
U101ACTIVE(tt, y0, U51(x0, x1, x2)) → FSTACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
U51ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → HEADACTIVE(afterNthActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U91ACTIVE(tt, XS) → MARK(XS)
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
U101ACTIVE(tt, y0, U71(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
U101ACTIVE(tt, U51(x0, x1, x2), y1) → FSTACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(pair(x1, x2)) → MARK(x1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
U51ACTIVE(tt, y0, splitAt(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
U51ACTIVE(tt, y0, U82(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(tail(U31(x0, x1))) → TAILACTIVE(U31Active(mark(x0), x1))
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U51ACTIVE(tt, y0, natsFrom(x0)) → HEADACTIVE(afterNthActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, y0, isNatural(x0)) → HEADACTIVE(afterNthActive(mark(y0), isNaturalActive(x0)))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(splitAt(U11(x0, x1, x2), y1)) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(splitAt(sel(x0, x1), y1)) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
U51ACTIVE(tt, y0, pair(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(tail(fst(x0))) → TAILACTIVE(fstActive(mark(x0)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
U51ACTIVE(tt, and(x0, x1), y1) → HEADACTIVE(afterNthActive(andActive(mark(x0), x1), mark(y1)))
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
U51ACTIVE(tt, isPLNat(x0), y1) → HEADACTIVE(afterNthActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, U71(x0, x1), y1) → HEADACTIVE(afterNthActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, y1) → HEADACTIVE(U11Active(andActive(isNaturalActive(mark(y0)), isLNat(mark(y1))), mark(y0), mark(y1)))
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(take(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(tail(splitAt(x0, x1))) → TAILACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
U51ACTIVE(tt, isLNat(x0), y1) → HEADACTIVE(afterNthActive(isLNatActive(x0), mark(y1)))
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
U51ACTIVE(tt, fst(x0), y1) → HEADACTIVE(afterNthActive(fstActive(mark(x0)), mark(y1)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
MARK(tail(U61(x0, x1))) → TAILACTIVE(U61Active(mark(x0), x1))
MARK(snd(splitAt(x0, x1))) → SNDACTIVE(splitAtActive(mark(x0), mark(x1)))
ISLNATACTIVE(take(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, y0, sel(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
U51ACTIVE(tt, U81(x0, x1, x2, x3), y1) → HEADACTIVE(afterNthActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
ISPLNATACTIVE(splitAt(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
U51ACTIVE(tt, y0, take(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, and(x0, x1), y1) → FSTACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
U101ACTIVE(tt, y0, fst(x0)) → FSTACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
U101ACTIVE(tt, nil, y1) → FSTACTIVE(splitAtActive(nil, mark(y1)))
U101ACTIVE(tt, y0, nil) → FSTACTIVE(splitAtActive(mark(y0), nil))
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x2)
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
U101ACTIVE(tt, y0, afterNth(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
U51ACTIVE(tt, U11(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U11Active(mark(x0), x1, x2), mark(y1)))
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U101ACTIVE(tt, fst(x0), y1) → FSTACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(tail(U41(x0, x1))) → TAILACTIVE(U41Active(mark(x0), x1))
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(splitAt(splitAt(x0, x1), y1)) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(snd(U81(x0, x1, x2, x3))) → SNDACTIVE(U81Active(mark(x0), x1, x2, x3))
U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS))
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
U51ACTIVE(tt, U61(x0, x1), y1) → HEADACTIVE(afterNthActive(U61Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, cons(x0, x1), y1) → FSTACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, isLNat(x0), y1) → FSTACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(splitAt(snd(x0), y1)) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U101ACTIVE(tt, pair(x0, x1), y1) → FSTACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(tail(U81(x0, x1, x2, x3))) → TAILACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, y0, sel(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(snd(take(x0, x1))) → SNDACTIVE(takeActive(mark(x0), mark(x1)))
U51ACTIVE(tt, y0, U31(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(splitAt(U21(x0, x1), y1)) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
U101ACTIVE(tt, y0, U31(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(splitAt(U81(x0, x1, x2, x3), y1)) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U51ACTIVE(tt, isNatural(x0), y1) → HEADACTIVE(afterNthActive(isNaturalActive(x0), mark(y1)))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, U11(x0, x1, x2), y1) → FSTACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(take(x1, x2)) → MARK(x1)
MARK(snd(U51(x0, x1, x2))) → SNDACTIVE(U51Active(mark(x0), x1, x2))
MARK(splitAt(take(x0, x1), y1)) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
U101ACTIVE(tt, y0, tail(x0)) → FSTACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(snd(tail(x0))) → SNDACTIVE(tailActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(tail(sel(x0, x1))) → TAILACTIVE(selActive(mark(x0), mark(x1)))
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(splitAt(tail(x0), y1)) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
U51ACTIVE(tt, U31(x0, x1), y1) → HEADACTIVE(afterNthActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(snd(natsFrom(x0))) → SNDACTIVE(natsFromActive(mark(x0)))
MARK(U91(x1, x2)) → MARK(x1)
MARK(tail(U11(x0, x1, x2))) → TAILACTIVE(U11Active(mark(x0), x1, x2))
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
U101ACTIVE(tt, y0, take(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U51ACTIVE(tt, y0, afterNth(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
U101ACTIVE(tt, U21(x0, x1), y1) → FSTACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, y0, fst(x0)) → HEADACTIVE(afterNthActive(mark(y0), fstActive(mark(x0))))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
ISPLNATACTIVE(splitAt(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(splitAt(U41(x0, x1), y1)) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(snd(isLNat(x0))) → SNDACTIVE(isLNatActive(x0))
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
U101ACTIVE(tt, y0, head(x0)) → FSTACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
MARK(tail(U71(x0, x1))) → TAILACTIVE(U71Active(mark(x0), x1))
MARK(splitAt(s(x0), y1)) → SPLITATACTIVE(s(mark(x0)), mark(y1))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(splitAt(afterNth(x0, x1), y1)) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
U101ACTIVE(tt, y0, snd(x0)) → FSTACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(snd(U11(x0, x1, x2))) → SNDACTIVE(U11Active(mark(x0), x1, x2))
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(tail(U51(x0, x1, x2))) → TAILACTIVE(U51Active(mark(x0), x1, x2))
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
U101ACTIVE(tt, s(x0), y1) → FSTACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
AFTERNTHACTIVE(head(x0), y1) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U101ACTIVE(tt, y0, U61(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(splitAt(isNatural(x0), y1)) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(splitAt(head(x0), y1)) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
U51ACTIVE(tt, tt, y1) → HEADACTIVE(afterNthActive(tt, mark(y1)))
U51ACTIVE(tt, y0, tt) → HEADACTIVE(afterNthActive(mark(y0), tt))
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(snd(U41(x0, x1))) → SNDACTIVE(U41Active(mark(x0), x1))
MARK(tail(afterNth(x0, x1))) → TAILACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(tail(isLNat(x0))) → TAILACTIVE(isLNatActive(x0))
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
U101ACTIVE(tt, U91(x0, x1), y1) → FSTACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(and(x1, x2)) → MARK(x1)
AFTERNTHACTIVE(0, y1) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, U31(x0, x1), y1) → FSTACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U51ACTIVE(tt, y0, U41(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U41Active(mark(x0), x1)))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
MARK(splitAt(natsFrom(x0), y1)) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
AFTERNTHACTIVE(s(x0), y1) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U51(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U51Active(mark(x0), x1, x2)))
U51ACTIVE(tt, U91(x0, x1), y1) → HEADACTIVE(afterNthActive(U91Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, splitAt(x0, x1), y1) → FSTACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
U101ACTIVE(tt, U82(x0, x1), y1) → FSTACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(sel(x1, x2)) → MARK(x2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(tail(U101(x0, x1, x2))) → TAILACTIVE(U101Active(mark(x0), x1, x2))
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(cons(x1, x2)) → MARK(x1)
MARK(tail(snd(x0))) → TAILACTIVE(sndActive(mark(x0)))
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U61(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U61Active(mark(x0), x1)))
U101ACTIVE(tt, y0, cons(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
ISLNATACTIVE(take(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(splitAt(fst(x0), y1)) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
AFTERNTHACTIVE(sel(x0, x1), y1) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, y0, isLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isLNatActive(x0)))
U101ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → FSTACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(snd(fst(x0))) → SNDACTIVE(fstActive(mark(x0)))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
U51ACTIVE(tt, U41(x0, x1), y1) → HEADACTIVE(afterNthActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
MARK(tail(isNatural(x0))) → TAILACTIVE(isNaturalActive(x0))
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(splitAt(isLNat(x0), y1)) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U101ACTIVE(tt, y0, isNatural(x0)) → FSTACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, cons(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
U51ACTIVE(tt, splitAt(x0, x1), y1) → HEADACTIVE(afterNthActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(splitAt(U71(x0, x1), y1)) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
U101ACTIVE(tt, y0, pair(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(snd(afterNth(x0, x1))) → SNDACTIVE(afterNthActive(mark(x0), mark(x1)))
U51ACTIVE(tt, head(x0), y1) → HEADACTIVE(afterNthActive(headActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, cons(x0, x1), y1) → HEADACTIVE(afterNthActive(cons(mark(x0), x1), mark(y1)))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(natsFrom(x0))) → TAILACTIVE(natsFromActive(mark(x0)))
U51ACTIVE(tt, y0, isPLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isPLNatActive(x0)))
U51ACTIVE(tt, y0, U11(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U11Active(mark(x0), x1, x2)))
U101ACTIVE(tt, y0, U11(x0, x1, x2)) → FSTACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
U31ACTIVE(tt, N) → MARK(N)
MARK(splitAt(U31(x0, x1), y1)) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(tail(U21(x0, x1))) → TAILACTIVE(U21Active(mark(x0), x1))
MARK(splitAt(U51(x0, x1, x2), y1)) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
U101ACTIVE(tt, y0, isPLNat(x0)) → FSTACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, y0, U71(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U71Active(mark(x0), x1)))
U51ACTIVE(tt, pair(x0, x1), y1) → HEADACTIVE(afterNthActive(pair(mark(x0), mark(x1)), mark(y1)))
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(splitAt(and(x0, x1), y1)) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, sel(x0, x1), y1) → HEADACTIVE(afterNthActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
ISPLNATACTIVE(splitAt(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
MARK(tail(head(x0))) → TAILACTIVE(headActive(mark(x0)))
U41ACTIVE(tt, N) → MARK(N)

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule U101ACTIVE(tt, N, XS) → SPLITATACTIVE(mark(N), mark(XS)) at position [0] we obtained the following new rules:

U101ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
U101ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U101ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
U101ACTIVE(tt, nil, y1) → SPLITATACTIVE(nil, mark(y1))
U101ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U101ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
U101ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
U101ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
U101ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
U101ACTIVE(tt, pair(x0, x1), y1) → SPLITATACTIVE(pair(mark(x0), mark(x1)), mark(y1))
U101ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
U101ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U101ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
U101ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
U101ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U101ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U101ACTIVE(tt, cons(x0, x1), y1) → SPLITATACTIVE(cons(mark(x0), x1), mark(y1))
U101ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
U101ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
U101ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
U101ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
U101ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
U101ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
U101ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
U101ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
U101ACTIVE(tt, tt, y1) → SPLITATACTIVE(tt, mark(y1))
U101ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
U101ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
U101ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
U101ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
U101ACTIVE(tt, y0, U91(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(splitAt(U82(x0, x1), y1)) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
MARK(splitAt(U101(x0, x1, x2), y1)) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(snd(isNatural(x0))) → SNDACTIVE(isNaturalActive(x0))
U101ACTIVE(tt, afterNth(x0, x1), y1) → FSTACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(snd(U101(x0, x1, x2))) → SNDACTIVE(U101Active(mark(x0), x1, x2))
U51ACTIVE(tt, y0, U101(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U101Active(mark(x0), x1, x2)))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
ANDACTIVE(tt, X) → MARK(X)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U101ACTIVE(tt, y0, U101(x0, x1, x2)) → FSTACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(splitAt(0, y1)) → SPLITATACTIVE(0, mark(y1))
U51ACTIVE(tt, y0, U91(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U91Active(mark(x0), x1)))
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U101ACTIVE(tt, y0, and(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
MARK(U71(x1, x2)) → MARK(x1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
U101ACTIVE(tt, U81(x0, x1, x2, x3), y1) → FSTACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U101ACTIVE(tt, isPLNat(x0), y1) → FSTACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, s(x0), y1) → HEADACTIVE(afterNthActive(s(mark(x0)), mark(y1)))
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(tail(tail(x0))) → TAILACTIVE(tailActive(mark(x0)))
U101ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U51ACTIVE(tt, U82(x0, x1), y1) → HEADACTIVE(afterNthActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, y0, s(x0)) → FSTACTIVE(splitAtActive(mark(y0), s(mark(x0))))
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U101ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(snd(snd(x0))) → SNDACTIVE(sndActive(mark(x0)))
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
U51ACTIVE(tt, 0, y1) → HEADACTIVE(afterNthActive(0, mark(y1)))
U51ACTIVE(tt, y0, 0) → HEADACTIVE(afterNthActive(mark(y0), 0))
MARK(splitAt(x1, x2)) → MARK(x2)
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, U61(x0, x1), y1) → FSTACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
U101ACTIVE(tt, tail(x0), y1) → FSTACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
U101ACTIVE(tt, isNatural(x0), y1) → FSTACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
U101ACTIVE(tt, y0, splitAt(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
U101ACTIVE(tt, U71(x0, x1), y1) → FSTACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U51ACTIVE(tt, tail(x0), y1) → HEADACTIVE(afterNthActive(tailActive(mark(x0)), mark(y1)))
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
U101ACTIVE(tt, head(x0), y1) → FSTACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(tail(isPLNat(x0))) → TAILACTIVE(isPLNatActive(x0))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
U101ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(snd(U91(x0, x1))) → SNDACTIVE(U91Active(mark(x0), x1))
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U101ACTIVE(tt, 0, y1) → FSTACTIVE(splitAtActive(0, mark(y1)))
U101ACTIVE(tt, y0, 0) → FSTACTIVE(splitAtActive(mark(y0), 0))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
U51ACTIVE(tt, nil, y1) → HEADACTIVE(afterNthActive(nil, mark(y1)))
U51ACTIVE(tt, y0, nil) → HEADACTIVE(afterNthActive(mark(y0), nil))
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, take(x0, x1), y1) → FSTACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
U101ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U51ACTIVE(tt, y0, and(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), andActive(mark(x0), x1)))
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(snd(pair(x0, x1))) → SNDACTIVE(pair(mark(x0), mark(x1)))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, afterNth(x0, x1), y1) → HEADACTIVE(afterNthActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
MARK(snd(isPLNat(x0))) → SNDACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U21(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U21Active(mark(x0), x1)))
U101ACTIVE(tt, y0, U41(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
MARK(snd(U21(x0, x1))) → SNDACTIVE(U21Active(mark(x0), x1))
U51ACTIVE(tt, U21(x0, x1), y1) → HEADACTIVE(afterNthActive(U21Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(snd(U31(x0, x1))) → SNDACTIVE(U31Active(mark(x0), x1))
U101ACTIVE(tt, y0, U51(x0, x1, x2)) → FSTACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
U51ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → HEADACTIVE(afterNthActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U91ACTIVE(tt, XS) → MARK(XS)
U101ACTIVE(tt, y0, U71(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
U101ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
U51ACTIVE(tt, y0, splitAt(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(tail(U31(x0, x1))) → TAILACTIVE(U31Active(mark(x0), x1))
U51ACTIVE(tt, y0, isNatural(x0)) → HEADACTIVE(afterNthActive(mark(y0), isNaturalActive(x0)))
U101ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
MARK(splitAt(U11(x0, x1, x2), y1)) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
U51ACTIVE(tt, U71(x0, x1), y1) → HEADACTIVE(afterNthActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, y1) → HEADACTIVE(U11Active(andActive(isNaturalActive(mark(y0)), isLNat(mark(y1))), mark(y0), mark(y1)))
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
U101ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
ISLNATACTIVE(take(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, U81(x0, x1, x2, x3), y1) → HEADACTIVE(afterNthActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
U51ACTIVE(tt, y0, take(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
U51ACTIVE(tt, U11(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U11Active(mark(x0), x1, x2), mark(y1)))
U101ACTIVE(tt, fst(x0), y1) → FSTACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(splitAt(splitAt(x0, x1), y1)) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
U101ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(snd(U81(x0, x1, x2, x3))) → SNDACTIVE(U81Active(mark(x0), x1, x2, x3))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
U51ACTIVE(tt, U61(x0, x1), y1) → HEADACTIVE(afterNthActive(U61Active(mark(x0), x1), mark(y1)))
MARK(splitAt(snd(x0), y1)) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U101ACTIVE(tt, pair(x0, x1), y1) → FSTACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(tail(U81(x0, x1, x2, x3))) → TAILACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U101ACTIVE(tt, y0, sel(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(splitAt(U21(x0, x1), y1)) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, U11(x0, x1, x2), y1) → FSTACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x1)
MARK(snd(U51(x0, x1, x2))) → SNDACTIVE(U51Active(mark(x0), x1, x2))
MARK(splitAt(take(x0, x1), y1)) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, U31(x0, x1), y1) → HEADACTIVE(afterNthActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(snd(natsFrom(x0))) → SNDACTIVE(natsFromActive(mark(x0)))
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
U101ACTIVE(tt, pair(x0, x1), y1) → SPLITATACTIVE(pair(mark(x0), mark(x1)), mark(y1))
U101ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U101ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(splitAt(U41(x0, x1), y1)) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(tail(U71(x0, x1))) → TAILACTIVE(U71Active(mark(x0), x1))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(splitAt(afterNth(x0, x1), y1)) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(tail(U51(x0, x1, x2))) → TAILACTIVE(U51Active(mark(x0), x1, x2))
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(head(x0), y1) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
U101ACTIVE(tt, y0, U61(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
U51ACTIVE(tt, tt, y1) → HEADACTIVE(afterNthActive(tt, mark(y1)))
U51ACTIVE(tt, y0, tt) → HEADACTIVE(afterNthActive(mark(y0), tt))
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
MARK(U82(x1, x2)) → MARK(x1)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
MARK(and(x1, x2)) → MARK(x1)
AFTERNTHACTIVE(0, y1) → ANDACTIVE(tt, isLNat(y1))
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U101ACTIVE(tt, cons(x0, x1), y1) → SPLITATACTIVE(cons(mark(x0), x1), mark(y1))
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(splitAt(natsFrom(x0), y1)) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U51(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U51Active(mark(x0), x1, x2)))
U51ACTIVE(tt, U91(x0, x1), y1) → HEADACTIVE(afterNthActive(U91Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, splitAt(x0, x1), y1) → FSTACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(x1)) → MARK(x1)
MARK(tail(x1)) → MARK(x1)
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(tail(snd(x0))) → TAILACTIVE(sndActive(mark(x0)))
U51ACTIVE(tt, y0, U61(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U61Active(mark(x0), x1)))
ISLNATACTIVE(take(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, y0, isLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isLNatActive(x0)))
U101ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → FSTACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(snd(fst(x0))) → SNDACTIVE(fstActive(mark(x0)))
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, U41(x0, x1), y1) → HEADACTIVE(afterNthActive(U41Active(mark(x0), x1), mark(y1)))
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(tail(isNatural(x0))) → TAILACTIVE(isNaturalActive(x0))
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
MARK(splitAt(U71(x0, x1), y1)) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U101ACTIVE(tt, y0, pair(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
U51ACTIVE(tt, head(x0), y1) → HEADACTIVE(afterNthActive(headActive(mark(x0)), mark(y1)))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U11(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U11Active(mark(x0), x1, x2)))
U31ACTIVE(tt, N) → MARK(N)
U101ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(tail(U21(x0, x1))) → TAILACTIVE(U21Active(mark(x0), x1))
U101ACTIVE(tt, y0, isPLNat(x0)) → FSTACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
U101ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U51ACTIVE(tt, y0, U71(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U71Active(mark(x0), x1)))
U51ACTIVE(tt, pair(x0, x1), y1) → HEADACTIVE(afterNthActive(pair(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(splitAt(and(x0, x1), y1)) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, sel(x0, x1), y1) → HEADACTIVE(afterNthActive(selActive(mark(x0), mark(x1)), mark(y1)))
U101ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
U41ACTIVE(tt, N) → MARK(N)
U101ACTIVE(tt, natsFrom(x0), y1) → FSTACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(tail(take(x0, x1))) → TAILACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(tail(and(x0, x1))) → TAILACTIVE(andActive(mark(x0), x1))
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(snd(U71(x0, x1))) → SNDACTIVE(U71Active(mark(x0), x1))
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(tail(U91(x0, x1))) → TAILACTIVE(U91Active(mark(x0), x1))
U101ACTIVE(tt, U101(x0, x1, x2), y1) → FSTACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, U51(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
MARK(splitAt(U91(x0, x1), y1)) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
U101ACTIVE(tt, tt, y1) → FSTACTIVE(splitAtActive(tt, mark(y1)))
U101ACTIVE(tt, y0, tt) → FSTACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(snd(U61(x0, x1))) → SNDACTIVE(U61Active(mark(x0), x1))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
U51ACTIVE(tt, y0, head(x0)) → HEADACTIVE(afterNthActive(mark(y0), headActive(mark(x0))))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
U101ACTIVE(tt, y0, U21(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
U51ACTIVE(tt, N, XS) → MARK(N)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(splitAt(isPLNat(x0), y1)) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
U101ACTIVE(tt, snd(x0), y1) → FSTACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U101ACTIVE(tt, y0, U82(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U11(x1, x2, x3)) → MARK(x1)
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(tail(cons(x0, x1))) → TAILACTIVE(cons(mark(x0), x1))
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(snd(and(x0, x1))) → SNDACTIVE(andActive(mark(x0), x1))
MARK(snd(sel(x0, x1))) → SNDACTIVE(selActive(mark(x0), mark(x1)))
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
U101ACTIVE(tt, y0, isLNat(x0)) → FSTACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
U101ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
U101ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
U101ACTIVE(tt, sel(x0, x1), y1) → FSTACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U101ACTIVE(tt, tt, y1) → SPLITATACTIVE(tt, mark(y1))
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, snd(x0)) → HEADACTIVE(afterNthActive(mark(y0), sndActive(mark(x0))))
U101ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U101ACTIVE(tt, nil, y1) → SPLITATACTIVE(nil, mark(y1))
U51ACTIVE(tt, snd(x0), y1) → HEADACTIVE(afterNthActive(sndActive(mark(x0)), mark(y1)))
U101ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, natsFrom(x0), y1) → HEADACTIVE(afterNthActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
U51ACTIVE(tt, take(x0, x1), y1) → HEADACTIVE(afterNthActive(takeActive(mark(x0), mark(x1)), mark(y1)))
U51ACTIVE(tt, y0, s(x0)) → HEADACTIVE(afterNthActive(mark(y0), s(mark(x0))))
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(snd(U82(x0, x1))) → SNDACTIVE(U82Active(mark(x0), x1))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U51ACTIVE(tt, U101(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
U51ACTIVE(tt, y0, tail(x0)) → HEADACTIVE(afterNthActive(mark(y0), tailActive(mark(x0))))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
MARK(tail(U82(x0, x1))) → TAILACTIVE(U82Active(mark(x0), x1))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U101ACTIVE(tt, y0, natsFrom(x0)) → FSTACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
MARK(snd(head(x0))) → SNDACTIVE(headActive(mark(x0)))
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(take(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
MARK(splitAt(U61(x0, x1), y1)) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
U101ACTIVE(tt, U41(x0, x1), y1) → FSTACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
ISPLNATACTIVE(splitAt(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
U101ACTIVE(tt, U51(x0, x1, x2), y1) → FSTACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(pair(x1, x2)) → MARK(x1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
U51ACTIVE(tt, y0, U82(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U82Active(mark(x0), x1)))
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
U51ACTIVE(tt, y0, natsFrom(x0)) → HEADACTIVE(afterNthActive(mark(y0), natsFromActive(mark(x0))))
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(splitAt(sel(x0, x1), y1)) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
U51ACTIVE(tt, y0, pair(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(tail(fst(x0))) → TAILACTIVE(fstActive(mark(x0)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
U51ACTIVE(tt, and(x0, x1), y1) → HEADACTIVE(afterNthActive(andActive(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(pair(x1, x2)) → MARK(x2)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
U51ACTIVE(tt, isPLNat(x0), y1) → HEADACTIVE(afterNthActive(isPLNatActive(x0), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(tail(splitAt(x0, x1))) → TAILACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
U51ACTIVE(tt, isLNat(x0), y1) → HEADACTIVE(afterNthActive(isLNatActive(x0), mark(y1)))
U51ACTIVE(tt, fst(x0), y1) → HEADACTIVE(afterNthActive(fstActive(mark(x0)), mark(y1)))
MARK(tail(U61(x0, x1))) → TAILACTIVE(U61Active(mark(x0), x1))
MARK(snd(splitAt(x0, x1))) → SNDACTIVE(splitAtActive(mark(x0), mark(x1)))
ISLNATACTIVE(take(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U51ACTIVE(tt, y0, sel(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
ISPLNATACTIVE(splitAt(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, and(x0, x1), y1) → FSTACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, y0, fst(x0)) → FSTACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
U101ACTIVE(tt, nil, y1) → FSTACTIVE(splitAtActive(nil, mark(y1)))
U101ACTIVE(tt, y0, nil) → FSTACTIVE(splitAtActive(mark(y0), nil))
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
U101ACTIVE(tt, y0, afterNth(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(tail(U41(x0, x1))) → TAILACTIVE(U41Active(mark(x0), x1))
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U101ACTIVE(tt, cons(x0, x1), y1) → FSTACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
U101ACTIVE(tt, isLNat(x0), y1) → FSTACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
U101ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
MARK(snd(take(x0, x1))) → SNDACTIVE(takeActive(mark(x0), mark(x1)))
U51ACTIVE(tt, y0, U31(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
U101ACTIVE(tt, y0, U31(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(splitAt(U81(x0, x1, x2, x3), y1)) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U51ACTIVE(tt, isNatural(x0), y1) → HEADACTIVE(afterNthActive(isNaturalActive(x0), mark(y1)))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
U101ACTIVE(tt, y0, tail(x0)) → FSTACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(snd(tail(x0))) → SNDACTIVE(tailActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(tail(sel(x0, x1))) → TAILACTIVE(selActive(mark(x0), mark(x1)))
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(splitAt(tail(x0), y1)) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
U101ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
MARK(U91(x1, x2)) → MARK(x1)
MARK(tail(U11(x0, x1, x2))) → TAILACTIVE(U11Active(mark(x0), x1, x2))
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U101ACTIVE(tt, y0, take(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U51ACTIVE(tt, y0, afterNth(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
U101ACTIVE(tt, U21(x0, x1), y1) → FSTACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(natsFrom(x1)) → MARK(x1)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, y0, fst(x0)) → HEADACTIVE(afterNthActive(mark(y0), fstActive(mark(x0))))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
ISPLNATACTIVE(splitAt(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(snd(isLNat(x0))) → SNDACTIVE(isLNatActive(x0))
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
U101ACTIVE(tt, y0, head(x0)) → FSTACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
MARK(splitAt(s(x0), y1)) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U101ACTIVE(tt, y0, snd(x0)) → FSTACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
MARK(snd(U11(x0, x1, x2))) → SNDACTIVE(U11Active(mark(x0), x1, x2))
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
U101ACTIVE(tt, s(x0), y1) → FSTACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(splitAt(isNatural(x0), y1)) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(splitAt(head(x0), y1)) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
MARK(snd(U41(x0, x1))) → SNDACTIVE(U41Active(mark(x0), x1))
MARK(tail(afterNth(x0, x1))) → TAILACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(tail(isLNat(x0))) → TAILACTIVE(isLNatActive(x0))
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
U101ACTIVE(tt, U91(x0, x1), y1) → FSTACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, U31(x0, x1), y1) → FSTACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U51ACTIVE(tt, y0, U41(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U41Active(mark(x0), x1)))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
AFTERNTHACTIVE(s(x0), y1) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
U101ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
U101ACTIVE(tt, U82(x0, x1), y1) → FSTACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
MARK(sel(x1, x2)) → MARK(x2)
MARK(tail(U101(x0, x1, x2))) → TAILACTIVE(U101Active(mark(x0), x1, x2))
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
U101ACTIVE(tt, y0, cons(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(splitAt(fst(x0), y1)) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
AFTERNTHACTIVE(sel(x0, x1), y1) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(splitAt(isLNat(x0), y1)) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
U101ACTIVE(tt, y0, isNatural(x0)) → FSTACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U51ACTIVE(tt, y0, cons(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
U51ACTIVE(tt, splitAt(x0, x1), y1) → HEADACTIVE(afterNthActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(snd(afterNth(x0, x1))) → SNDACTIVE(afterNthActive(mark(x0), mark(x1)))
U51ACTIVE(tt, cons(x0, x1), y1) → HEADACTIVE(afterNthActive(cons(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
MARK(tail(natsFrom(x0))) → TAILACTIVE(natsFromActive(mark(x0)))
U51ACTIVE(tt, y0, isPLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isPLNatActive(x0)))
U101ACTIVE(tt, y0, U11(x0, x1, x2)) → FSTACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
MARK(splitAt(U31(x0, x1), y1)) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(splitAt(U51(x0, x1, x2), y1)) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
U101ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U101ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
ISPLNATACTIVE(splitAt(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(tail(head(x0))) → TAILACTIVE(headActive(mark(x0)))

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 4 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ Narrowing
            ↳ QDP
              ↳ DependencyGraphProof
                ↳ QDP
                  ↳ Narrowing
                    ↳ QDP
                      ↳ DependencyGraphProof
                        ↳ QDP
                          ↳ Narrowing
                            ↳ QDP
                              ↳ DependencyGraphProof
                                ↳ QDP
                                  ↳ Narrowing
                                    ↳ QDP
                                      ↳ DependencyGraphProof
                                        ↳ QDP
                                          ↳ Narrowing
                                            ↳ QDP
                                              ↳ DependencyGraphProof
                                                ↳ QDP
                                                  ↳ Narrowing
                                                    ↳ QDP
                                                      ↳ DependencyGraphProof
                                                        ↳ QDP
                                                          ↳ Narrowing
                                                            ↳ QDP
                                                              ↳ DependencyGraphProof
                                                                ↳ QDP
                                                                  ↳ Narrowing
                                                                    ↳ QDP
                                                                      ↳ DependencyGraphProof
                                                                        ↳ QDP
                                                                          ↳ Narrowing
                                                                            ↳ QDP
                                                                              ↳ DependencyGraphProof
                                                                                ↳ QDP
                                                                                  ↳ Narrowing
                                                                                    ↳ QDP
                                                                                      ↳ DependencyGraphProof
                                                                                        ↳ QDP
                                                                                          ↳ Narrowing
                                                                                            ↳ QDP
                                                                                              ↳ DependencyGraphProof
                                                                                                ↳ QDP
                                                                                                  ↳ Narrowing
                                                                                                    ↳ QDP
                                                                                                      ↳ DependencyGraphProof
                                                                                                        ↳ QDP
                                                                                                          ↳ Narrowing
                                                                                                            ↳ QDP
                                                                                                              ↳ DependencyGraphProof
                                                                                                                ↳ QDP
                                                                                                                  ↳ Narrowing
                                                                                                                    ↳ QDP
                                                                                                                      ↳ DependencyGraphProof
                                                                                                                        ↳ QDP
                                                                                                                          ↳ Narrowing
                                                                                                                            ↳ QDP
                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                ↳ QDP
                                                                                                                                  ↳ Narrowing
                                                                                                                                    ↳ QDP
                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                        ↳ QDP
                                                                                                                                          ↳ Narrowing
                                                                                                                                            ↳ QDP
                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                ↳ QDP
                                                                                                                                                  ↳ Narrowing
                                                                                                                                                    ↳ QDP
                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                        ↳ QDP
                                                                                                                                                          ↳ Narrowing
                                                                                                                                                            ↳ QDP
                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                ↳ QDP
                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                    ↳ QDP
                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                        ↳ QDP
                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                            ↳ QDP
                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                ↳ QDP
                                                                                                                                                                                                                                  ↳ Narrowing
                                                                                                                                                                                                                                    ↳ QDP
                                                                                                                                                                                                                                      ↳ DependencyGraphProof
                                                                                                                                                                                                                                        ↳ QDP
                                                                                                                                                                                                                                          ↳ Narrowing
                                                                                                                                                                                                                                            ↳ QDP
                                                                                                                                                                                                                                              ↳ DependencyGraphProof
                                                                                                                                                                                                                                                ↳ QDP
  ↳ Trivial-Transformation

Q DP problem:
The TRS P consists of the following rules:

MARK(fst(pair(x0, x1))) → FSTACTIVE(pair(mark(x0), mark(x1)))
MARK(U101(U91(x0, x1), y1, y2)) → U101ACTIVE(U91Active(mark(x0), x1), y1, y2)
U101ACTIVE(tt, y0, U91(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
MARK(U11(U11(x0, x1, x2), y1, y2)) → U11ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(U61(take(x0, x1), y1)) → U61ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U21(fst(x0), y1)) → U21ACTIVE(fstActive(mark(x0)), y1)
MARK(U82(U41(x0, x1), y1)) → U82ACTIVE(U41Active(mark(x0), x1), y1)
MARK(splitAt(U82(x0, x1), y1)) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(U51(head(x0), y1, y2)) → U51ACTIVE(headActive(mark(x0)), y1, y2)
MARK(and(U21(x0, x1), y1)) → ANDACTIVE(U21Active(mark(x0), x1), y1)
MARK(U61(tt, y1)) → U61ACTIVE(tt, y1)
MARK(splitAt(U101(x0, x1, x2), y1)) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
TAILACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
ISPLNATACTIVE(pair(snd(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
MARK(U81(isLNat(x0), y1, y2, y3)) → U81ACTIVE(isLNatActive(x0), y1, y2, y3)
MARK(U41(x1, x2)) → MARK(x1)
MARK(U91(U51(x0, x1, x2), y1)) → U91ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U101(splitAt(x0, x1), y1, y2)) → U101ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(fst(snd(x0))) → FSTACTIVE(sndActive(mark(x0)))
MARK(snd(isNatural(x0))) → SNDACTIVE(isNaturalActive(x0))
U101ACTIVE(tt, afterNth(x0, x1), y1) → FSTACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(cons(0, y1)) → ANDACTIVE(tt, isLNat(y1))
HEADACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(snd(U101(x0, x1, x2))) → SNDACTIVE(U101Active(mark(x0), x1, x2))
U51ACTIVE(tt, y0, U101(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U101Active(mark(x0), x1, x2)))
U11ACTIVE(tt, 0, y1) → SNDACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, y0, 0) → SNDACTIVE(splitAtActive(mark(y0), 0))
ISLNATACTIVE(cons(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U61(isPLNat(x0), y1)) → U61ACTIVE(isPLNatActive(x0), y1)
ANDACTIVE(tt, X) → MARK(X)
MARK(U31(U11(x0, x1, x2), y1)) → U31ACTIVE(U11Active(mark(x0), x1, x2), y1)
TAKEACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U101ACTIVE(tt, y0, U101(x0, x1, x2)) → FSTACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
ISLNATACTIVE(afterNth(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(splitAt(0, y1)) → SPLITATACTIVE(0, mark(y1))
U51ACTIVE(tt, y0, U91(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U91Active(mark(x0), x1)))
U101ACTIVE(tt, y0, and(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
MARK(and(U81(x0, x1, x2, x3), y1)) → ANDACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U71(x1, x2)) → MARK(x1)
U81ACTIVE(tt, N, X, XS) → SPLITATACTIVE(mark(N), mark(XS))
U101ACTIVE(tt, U81(x0, x1, x2, x3), y1) → FSTACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
NATSFROMACTIVE(N) → ISNATURALACTIVE(N)
U101ACTIVE(tt, isPLNat(x0), y1) → FSTACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
U51ACTIVE(tt, s(x0), y1) → HEADACTIVE(afterNthActive(s(mark(x0)), mark(y1)))
SPLITATACTIVE(0, XS) → U71ACTIVE(isLNatActive(XS), XS)
MARK(U81(x1, x2, x3, x4)) → MARK(x1)
MARK(tail(tail(x0))) → TAILACTIVE(tailActive(mark(x0)))
U101ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(U31(fst(x0), y1)) → U31ACTIVE(fstActive(mark(x0)), y1)
U51ACTIVE(tt, U82(x0, x1), y1) → HEADACTIVE(afterNthActive(U82Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, y0, s(x0)) → FSTACTIVE(splitAtActive(mark(y0), s(mark(x0))))
MARK(U101(U61(x0, x1), y1, y2)) → U101ACTIVE(U61Active(mark(x0), x1), y1, y2)
U101ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
MARK(U82(splitAt(x0, x1), y1)) → U82ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U31(U91(x0, x1), y1)) → U31ACTIVE(U91Active(mark(x0), x1), y1)
MARK(snd(snd(x0))) → SNDACTIVE(sndActive(mark(x0)))
MARK(head(U82(x0, x1))) → HEADACTIVE(U82Active(mark(x0), x1))
MARK(U51(isLNat(x0), y1, y2)) → U51ACTIVE(isLNatActive(x0), y1, y2)
MARK(splitAt(x1, x2)) → MARK(x2)
U51ACTIVE(tt, y0, 0) → HEADACTIVE(afterNthActive(mark(y0), 0))
U51ACTIVE(tt, 0, y1) → HEADACTIVE(afterNthActive(0, mark(y1)))
MARK(U51(U91(x0, x1), y1, y2)) → U51ACTIVE(U91Active(mark(x0), x1), y1, y2)
MARK(U71(take(x0, x1), y1)) → U71ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, U61(x0, x1), y1) → FSTACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(U31(snd(x0), y1)) → U31ACTIVE(sndActive(mark(x0)), y1)
MARK(head(natsFrom(x0))) → HEADACTIVE(natsFromActive(mark(x0)))
MARK(U91(U82(x0, x1), y1)) → U91ACTIVE(U82Active(mark(x0), x1), y1)
MARK(head(tail(x0))) → HEADACTIVE(tailActive(mark(x0)))
MARK(head(fst(x0))) → HEADACTIVE(fstActive(mark(x0)))
U101ACTIVE(tt, tail(x0), y1) → FSTACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
MARK(U61(U51(x0, x1, x2), y1)) → U61ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(afterNth(x1, x2)) → MARK(x1)
U101ACTIVE(tt, isNatural(x0), y1) → FSTACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
U101ACTIVE(tt, y0, splitAt(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
U101ACTIVE(tt, U71(x0, x1), y1) → FSTACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U91(splitAt(x0, x1), y1)) → U91ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(head(take(x0, x1))) → HEADACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U81(afterNth(x0, x1), y1, y2, y3)) → U81ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2, y3)
U51ACTIVE(tt, tail(x0), y1) → HEADACTIVE(afterNthActive(tailActive(mark(x0)), mark(y1)))
MARK(U51(natsFrom(x0), y1, y2)) → U51ACTIVE(natsFromActive(mark(x0)), y1, y2)
U11ACTIVE(tt, y0, U101(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U101Active(mark(x0), x1, x2)))
U101ACTIVE(tt, head(x0), y1) → FSTACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(tail(isPLNat(x0))) → TAILACTIVE(isPLNatActive(x0))
MARK(U61(isNatural(x0), y1)) → U61ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(U81(U91(x0, x1), y1, y2, y3)) → U81ACTIVE(U91Active(mark(x0), x1), y1, y2, y3)
MARK(U11(isNatural(x0), y1, y2)) → U11ACTIVE(isNaturalActive(x0), y1, y2)
U101ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
MARK(U31(and(x0, x1), y1)) → U31ACTIVE(andActive(mark(x0), x1), y1)
MARK(snd(U91(x0, x1))) → SNDACTIVE(U91Active(mark(x0), x1))
MARK(U91(sel(x0, x1), y1)) → U91ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(U71(fst(x0), y1)) → U71ACTIVE(fstActive(mark(x0)), y1)
MARK(U101(natsFrom(x0), y1, y2)) → U101ACTIVE(natsFromActive(mark(x0)), y1, y2)
MARK(U11(tt, y1, y2)) → U11ACTIVE(tt, y1, y2)
U11ACTIVE(tt, y0, head(x0)) → SNDACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SNDACTIVE(splitAtActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U101ACTIVE(tt, y0, 0) → FSTACTIVE(splitAtActive(mark(y0), 0))
U101ACTIVE(tt, 0, y1) → FSTACTIVE(splitAtActive(0, mark(y1)))
U11ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(head(U91(x0, x1))) → HEADACTIVE(U91Active(mark(x0), x1))
MARK(U11(sel(x0, x1), y1, y2)) → U11ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(fst(x0), y1, y2)) → U101ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(U91(isNatural(x0), y1)) → U91ACTIVE(isNaturalActive(x0), y1)
U51ACTIVE(tt, y0, nil) → HEADACTIVE(afterNthActive(mark(y0), nil))
U51ACTIVE(tt, nil, y1) → HEADACTIVE(afterNthActive(nil, mark(y1)))
MARK(U51(U41(x0, x1), y1, y2)) → U51ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(take(x0, x1), y1)) → U91ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, take(x0, x1), y1) → FSTACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U31(x0, x1), y1, y2)) → U11ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, sel(x0, x1), y1) → SNDACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(U41(U91(x0, x1), y1)) → U41ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, U21(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(U71(isNatural(x0), y1)) → U71ACTIVE(isNaturalActive(x0), y1)
U11ACTIVE(tt, y0, afterNth(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
U11ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
U101ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U11ACTIVE(tt, y0, fst(x0)) → SNDACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
U51ACTIVE(tt, y0, and(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), andActive(mark(x0), x1)))
MARK(U41(and(x0, x1), y1)) → U41ACTIVE(andActive(mark(x0), x1), y1)
MARK(snd(pair(x0, x1))) → SNDACTIVE(pair(mark(x0), mark(x1)))
U11ACTIVE(tt, fst(x0), y1) → SNDACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
U51ACTIVE(tt, afterNth(x0, x1), y1) → HEADACTIVE(afterNthActive(afterNthActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
MARK(snd(isPLNat(x0))) → SNDACTIVE(isPLNatActive(x0))
U11ACTIVE(tt, pair(x0, x1), y1) → SNDACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U81(x0, x1, x2, x3), y1, y2)) → U11ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U11ACTIVE(tt, y0, sel(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U61(head(x0), y1)) → U61ACTIVE(headActive(mark(x0)), y1)
MARK(U91(U71(x0, x1), y1)) → U91ACTIVE(U71Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U21(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U21Active(mark(x0), x1)))
U101ACTIVE(tt, y0, U41(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
MARK(snd(U21(x0, x1))) → SNDACTIVE(U21Active(mark(x0), x1))
U51ACTIVE(tt, U21(x0, x1), y1) → HEADACTIVE(afterNthActive(U21Active(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(afterNth(x0, x1), y1)) → U91ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U31(U61(x0, x1), y1)) → U31ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U91(fst(x0), y1)) → U91ACTIVE(fstActive(mark(x0)), y1)
U101ACTIVE(tt, y0, U51(x0, x1, x2)) → FSTACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(snd(U31(x0, x1))) → SNDACTIVE(U31Active(mark(x0), x1))
U11ACTIVE(tt, y0, U41(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U41Active(mark(x0), x1)))
U51ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → HEADACTIVE(afterNthActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(U71(U91(x0, x1), y1)) → U71ACTIVE(U91Active(mark(x0), x1), y1)
U91ACTIVE(tt, XS) → MARK(XS)
U101ACTIVE(tt, y0, U71(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
U101ACTIVE(tt, U91(x0, x1), y1) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
MARK(U31(natsFrom(x0), y1)) → U31ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U71(U61(x0, x1), y1)) → U71ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U31(tail(x0), y1)) → U31ACTIVE(tailActive(mark(x0)), y1)
MARK(U101(sel(x0, x1), y1, y2)) → U101ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
MARK(U71(U81(x0, x1, x2, x3), y1)) → U71ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U41(U81(x0, x1, x2, x3), y1)) → U41ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → U81ACTIVE(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
U51ACTIVE(tt, y0, splitAt(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U31(U41(x0, x1), y1)) → U31ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(x1, x2)) → MARK(x1)
MARK(tail(U31(x0, x1))) → TAILACTIVE(U31Active(mark(x0), x1))
U51ACTIVE(tt, y0, isNatural(x0)) → HEADACTIVE(afterNthActive(mark(y0), isNaturalActive(x0)))
U101ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
ISPLNATACTIVE(pair(take(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(splitAt(U11(x0, x1, x2), y1)) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
MARK(U31(x1, x2)) → MARK(x1)
MARK(U71(U51(x0, x1, x2), y1)) → U71ACTIVE(U51Active(mark(x0), x1, x2), y1)
ISNATURALACTIVE(sel(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U41(U11(x0, x1, x2), y1)) → U41ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U41(isPLNat(x0), y1)) → U41ACTIVE(isPLNatActive(x0), y1)
MARK(U81(tt, y1, y2, y3)) → U81ACTIVE(tt, y1, y2, y3)
MARK(U51(tt, y1, y2)) → U51ACTIVE(tt, y1, y2)
MARK(snd(x1)) → MARK(x1)
U51ACTIVE(tt, U71(x0, x1), y1) → HEADACTIVE(afterNthActive(U71Active(mark(x0), x1), mark(y1)))
MARK(U91(U91(x0, x1), y1)) → U91ACTIVE(U91Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, y1) → HEADACTIVE(U11Active(andActive(isNaturalActive(mark(y0)), isLNat(mark(y1))), mark(y0), mark(y1)))
MARK(head(isPLNat(x0))) → HEADACTIVE(isPLNatActive(x0))
MARK(U31(head(x0), y1)) → U31ACTIVE(headActive(mark(x0)), y1)
U101ACTIVE(tt, U21(x0, x1), y1) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(U81(natsFrom(x0), y1, y2, y3)) → U81ACTIVE(natsFromActive(mark(x0)), y1, y2, y3)
MARK(head(sel(x0, x1))) → HEADACTIVE(selActive(mark(x0), mark(x1)))
ISLNATACTIVE(take(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U81(isPLNat(x0), y1, y2, y3)) → U81ACTIVE(isPLNatActive(x0), y1, y2, y3)
U11ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U82(head(x0), y1)) → U82ACTIVE(headActive(mark(x0)), y1)
MARK(fst(fst(x0))) → FSTACTIVE(fstActive(mark(x0)))
MARK(head(U61(x0, x1))) → HEADACTIVE(U61Active(mark(x0), x1))
MARK(and(isNatural(x0), y1)) → ANDACTIVE(isNaturalActive(x0), y1)
MARK(natsFrom(x1)) → NATSFROMACTIVE(mark(x1))
U11ACTIVE(tt, y0, isNatural(x0)) → SNDACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
FSTACTIVE(pair(X, Y)) → U21ACTIVE(andActive(isLNatActive(X), isLNat(Y)), X)
MARK(U61(natsFrom(x0), y1)) → U61ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U101(U101(x0, x1, x2), y1, y2)) → U101ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
ISPLNATACTIVE(splitAt(V1, V2)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, U81(x0, x1, x2, x3), y1) → HEADACTIVE(afterNthActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(fst(tail(x0))) → FSTACTIVE(tailActive(mark(x0)))
MARK(U82(U81(x0, x1, x2, x3), y1)) → U82ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U31(afterNth(x0, x1), y1)) → U31ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U71(and(x0, x1), y1)) → U71ACTIVE(andActive(mark(x0), x1), y1)
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
U51ACTIVE(tt, y0, take(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U101(head(x0), y1, y2)) → U101ACTIVE(headActive(mark(x0)), y1, y2)
MARK(head(U41(x0, x1))) → HEADACTIVE(U41Active(mark(x0), x1))
MARK(U61(U61(x0, x1), y1)) → U61ACTIVE(U61Active(mark(x0), x1), y1)
MARK(head(U51(x0, x1, x2))) → HEADACTIVE(U51Active(mark(x0), x1, x2))
MARK(head(isNatural(x0))) → HEADACTIVE(isNaturalActive(x0))
U11ACTIVE(tt, y0, and(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), andActive(mark(x0), x1)))
U51ACTIVE(tt, U11(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U11Active(mark(x0), x1, x2), mark(y1)))
U101ACTIVE(tt, fst(x0), y1) → FSTACTIVE(splitAtActive(fstActive(mark(x0)), mark(y1)))
MARK(U21(sel(x0, x1), y1)) → U21ACTIVE(selActive(mark(x0), mark(x1)), y1)
ISLNATACTIVE(cons(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U21(splitAt(x0, x1), y1)) → U21ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(splitAt(splitAt(x0, x1), y1)) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
MARK(U11(U51(x0, x1, x2), y1, y2)) → U11ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(fst(U21(x0, x1))) → FSTACTIVE(U21Active(mark(x0), x1))
MARK(U11(fst(x0), y1, y2)) → U11ACTIVE(fstActive(mark(x0)), y1, y2)
U101ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
MARK(U61(U82(x0, x1), y1)) → U61ACTIVE(U82Active(mark(x0), x1), y1)
MARK(snd(U81(x0, x1, x2, x3))) → SNDACTIVE(U81Active(mark(x0), x1, x2, x3))
U81ACTIVE(tt, N, X, XS) → U82ACTIVE(splitAtActive(mark(N), mark(XS)), X)
U51ACTIVE(tt, U61(x0, x1), y1) → HEADACTIVE(afterNthActive(U61Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, pair(x0, x1), y1) → FSTACTIVE(splitAtActive(pair(mark(x0), mark(x1)), mark(y1)))
MARK(splitAt(snd(x0), y1)) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
MARK(U81(U41(x0, x1), y1, y2, y3)) → U81ACTIVE(U41Active(mark(x0), x1), y1, y2, y3)
MARK(tail(U81(x0, x1, x2, x3))) → TAILACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(head(U101(x0, x1, x2))) → HEADACTIVE(U101Active(mark(x0), x1, x2))
SELACTIVE(N, XS) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
U101ACTIVE(tt, y0, sel(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(U91(U41(x0, x1), y1)) → U91ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, N, XS) → MARK(XS)
MARK(U91(U31(x0, x1), y1)) → U91ACTIVE(U31Active(mark(x0), x1), y1)
MARK(fst(U82(x0, x1))) → FSTACTIVE(U82Active(mark(x0), x1))
MARK(head(isLNat(x0))) → HEADACTIVE(isLNatActive(x0))
MARK(splitAt(U21(x0, x1), y1)) → SPLITATACTIVE(U21Active(mark(x0), x1), mark(y1))
MARK(head(U11(x0, x1, x2))) → HEADACTIVE(U11Active(mark(x0), x1, x2))
MARK(and(snd(x0), y1)) → ANDACTIVE(sndActive(mark(x0)), y1)
MARK(U21(afterNth(x0, x1), y1)) → U21ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, U11(x0, x1, x2), y1) → FSTACTIVE(splitAtActive(U11Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(U31(x0, x1), y1)) → U61ACTIVE(U31Active(mark(x0), x1), y1)
MARK(take(x1, x2)) → MARK(x1)
MARK(snd(U51(x0, x1, x2))) → SNDACTIVE(U51Active(mark(x0), x1, x2))
MARK(splitAt(take(x0, x1), y1)) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
ISLNATACTIVE(take(V1, V2)) → ISNATURALACTIVE(V1)
MARK(U101(afterNth(x0, x1), y1, y2)) → U101ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U51ACTIVE(tt, U31(x0, x1), y1) → HEADACTIVE(afterNthActive(U31Active(mark(x0), x1), mark(y1)))
MARK(snd(natsFrom(x0))) → SNDACTIVE(natsFromActive(mark(x0)))
MARK(U41(take(x0, x1), y1)) → U41ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U82(snd(x0), y1)) → U82ACTIVE(sndActive(mark(x0)), y1)
MARK(U31(sel(x0, x1), y1)) → U31ACTIVE(selActive(mark(x0), mark(x1)), y1)
U61ACTIVE(tt, Y) → MARK(Y)
MARK(U51(afterNth(x0, x1), y1, y2)) → U51ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
U81ACTIVE(tt, N, X, XS) → MARK(N)
MARK(U21(U101(x0, x1, x2), y1)) → U21ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, isNatural(x0), y1) → SNDACTIVE(splitAtActive(isNaturalActive(x0), mark(y1)))
MARK(U51(U82(x0, x1), y1, y2)) → U51ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U31(x0, x1), y1, y2)) → U51ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, U91(x0, x1), y1) → SNDACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
ISLNATACTIVE(fst(V1)) → ISPLNATACTIVE(V1)
MARK(U82(sel(x0, x1), y1)) → U82ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(fst(x0), y1)) → ANDACTIVE(fstActive(mark(x0)), y1)
U101ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U101ACTIVE(tt, U51(x0, x1, x2), y1) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(U51(isNatural(x0), y1, y2)) → U51ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U11(afterNth(x0, x1), y1, y2)) → U11ACTIVE(afterNthActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(isPLNat(x0), y1, y2)) → U101ACTIVE(isPLNatActive(x0), y1, y2)
U11ACTIVE(tt, isPLNat(x0), y1) → SNDACTIVE(splitAtActive(isPLNatActive(x0), mark(y1)))
MARK(fst(splitAt(x0, x1))) → FSTACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U61(fst(x0), y1)) → U61ACTIVE(fstActive(mark(x0)), y1)
MARK(U31(U51(x0, x1, x2), y1)) → U31ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, N, XS) → MARK(N)
MARK(splitAt(U41(x0, x1), y1)) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(tail(U71(x0, x1))) → TAILACTIVE(U71Active(mark(x0), x1))
MARK(U101(tt, y1, y2)) → U101ACTIVE(tt, y1, y2)
MARK(U91(U101(x0, x1, x2), y1)) → U91ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(splitAt(afterNth(x0, x1), y1)) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
MARK(U61(U21(x0, x1), y1)) → U61ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U81(U101(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U101Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U82(isNatural(x0), y1)) → U82ACTIVE(isNaturalActive(x0), y1)
MARK(U31(U71(x0, x1), y1)) → U31ACTIVE(U71Active(mark(x0), x1), y1)
MARK(tail(U51(x0, x1, x2))) → TAILACTIVE(U51Active(mark(x0), x1, x2))
AFTERNTHACTIVE(head(x0), y1) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(head(U31(x0, x1))) → HEADACTIVE(U31Active(mark(x0), x1))
NATSFROMACTIVE(N) → U41ACTIVE(isNaturalActive(N), N)
MARK(U91(snd(x0), y1)) → U91ACTIVE(sndActive(mark(x0)), y1)
MARK(fst(x1)) → MARK(x1)
U101ACTIVE(tt, y0, U61(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
MARK(head(U71(x0, x1))) → HEADACTIVE(U71Active(mark(x0), x1))
MARK(fst(head(x0))) → FSTACTIVE(headActive(mark(x0)))
U11ACTIVE(tt, y0, U31(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
SNDACTIVE(pair(X, Y)) → U61ACTIVE(andActive(isLNatActive(X), isLNat(Y)), Y)
U51ACTIVE(tt, y0, tt) → HEADACTIVE(afterNthActive(mark(y0), tt))
U51ACTIVE(tt, tt, y1) → HEADACTIVE(afterNthActive(tt, mark(y1)))
MARK(U82(x1, x2)) → MARK(x1)
MARK(U51(U81(x0, x1, x2, x3), y1, y2)) → U51ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U81ACTIVE(tt, N, X, XS) → MARK(XS)
MARK(U82(pair(x0, x1), y1)) → U82ACTIVE(pair(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, head(x0), y1) → SNDACTIVE(splitAtActive(headActive(mark(x0)), mark(y1)))
MARK(U91(tail(x0), y1)) → U91ACTIVE(tailActive(mark(x0)), y1)
MARK(and(and(x0, x1), y1)) → ANDACTIVE(andActive(mark(x0), x1), y1)
AFTERNTHACTIVE(0, y1) → ANDACTIVE(tt, isLNat(y1))
MARK(and(x1, x2)) → MARK(x1)
MARK(U71(head(x0), y1)) → U71ACTIVE(headActive(mark(x0)), y1)
MARK(U31(U82(x0, x1), y1)) → U31ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U51(and(x0, x1), y1, y2)) → U51ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(fst(U71(x0, x1))) → FSTACTIVE(U71Active(mark(x0), x1))
ISPLNATACTIVE(pair(nil, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(U31(isNatural(x0), y1)) → U31ACTIVE(isNaturalActive(x0), y1)
MARK(U21(take(x0, x1), y1)) → U21ACTIVE(takeActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
U11ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(splitAt(natsFrom(x0), y1)) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U31(U31(x0, x1), y1)) → U31ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U101(U82(x0, x1), y1, y2)) → U101ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(U51(U21(x0, x1), y1, y2)) → U51ACTIVE(U21Active(mark(x0), x1), y1, y2)
U101ACTIVE(tt, splitAt(x0, x1), y1) → FSTACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
U51ACTIVE(tt, U91(x0, x1), y1) → HEADACTIVE(afterNthActive(U91Active(mark(x0), x1), mark(y1)))
U51ACTIVE(tt, y0, U51(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(U61(U71(x0, x1), y1)) → U61ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(U71(x0, x1), y1, y2)) → U101ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U51(take(x0, x1), y1, y2)) → U51ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U101(tail(x0), y1, y2)) → U101ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U101(isNatural(x0), y1, y2)) → U101ACTIVE(isNaturalActive(x0), y1, y2)
MARK(U91(U81(x0, x1, x2, x3), y1)) → U91ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(U61(x0, x1), y1)) → U91ACTIVE(U61Active(mark(x0), x1), y1)
MARK(tail(x1)) → MARK(x1)
MARK(head(x1)) → MARK(x1)
U11ACTIVE(tt, U61(x0, x1), y1) → SNDACTIVE(splitAtActive(U61Active(mark(x0), x1), mark(y1)))
MARK(fst(take(x0, x1))) → FSTACTIVE(takeActive(mark(x0), mark(x1)))
MARK(tail(snd(x0))) → TAILACTIVE(sndActive(mark(x0)))
ISLNATACTIVE(take(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U51ACTIVE(tt, y0, U61(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U61Active(mark(x0), x1)))
U11ACTIVE(tt, isLNat(x0), y1) → SNDACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
U101ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → FSTACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
U51ACTIVE(tt, y0, isLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isLNatActive(x0)))
MARK(U61(U11(x0, x1, x2), y1)) → U61ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U82(U101(x0, x1, x2), y1)) → U82ACTIVE(U101Active(mark(x0), x1, x2), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ANDACTIVE(isNaturalActive(N), and(isNatural(X), isLNat(XS)))
MARK(snd(fst(x0))) → SNDACTIVE(fstActive(mark(x0)))
MARK(U82(U11(x0, x1, x2), y1)) → U82ACTIVE(U11Active(mark(x0), x1, x2), y1)
U51ACTIVE(tt, U41(x0, x1), y1) → HEADACTIVE(afterNthActive(U41Active(mark(x0), x1), mark(y1)))
ISPLNATACTIVE(pair(natsFrom(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(afterNth(x1, x2)) → MARK(x2)
MARK(U41(isNatural(x0), y1)) → U41ACTIVE(isNaturalActive(x0), y1)
MARK(and(U91(x0, x1), y1)) → ANDACTIVE(U91Active(mark(x0), x1), y1)
MARK(tail(isNatural(x0))) → TAILACTIVE(isNaturalActive(x0))
MARK(U51(U71(x0, x1), y1, y2)) → U51ACTIVE(U71Active(mark(x0), x1), y1, y2)
MARK(U91(tt, y1)) → U91ACTIVE(tt, y1)
MARK(head(head(x0))) → HEADACTIVE(headActive(mark(x0)))
MARK(fst(U11(x0, x1, x2))) → FSTACTIVE(U11Active(mark(x0), x1, x2))
MARK(U41(U31(x0, x1), y1)) → U41ACTIVE(U31Active(mark(x0), x1), y1)
U11ACTIVE(tt, isPLNat(x0), y1) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
U101ACTIVE(tt, y0, pair(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(splitAt(U71(x0, x1), y1)) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
MARK(U81(splitAt(x0, x1), y1, y2, y3)) → U81ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2, y3)
MARK(head(cons(x0, x1))) → HEADACTIVE(cons(mark(x0), x1))
U51ACTIVE(tt, head(x0), y1) → HEADACTIVE(afterNthActive(headActive(mark(x0)), mark(y1)))
MARK(U91(and(x0, x1), y1)) → U91ACTIVE(andActive(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U11(x0, x1, x2)) → HEADACTIVE(afterNthActive(mark(y0), U11Active(mark(x0), x1, x2)))
U31ACTIVE(tt, N) → MARK(N)
U101ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(tail(U21(x0, x1))) → TAILACTIVE(U21Active(mark(x0), x1))
U101ACTIVE(tt, y0, isPLNat(x0)) → FSTACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
MARK(U71(U101(x0, x1, x2), y1)) → U71ACTIVE(U101Active(mark(x0), x1, x2), y1)
U101ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U51ACTIVE(tt, y0, U71(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U71Active(mark(x0), x1)))
U51ACTIVE(tt, pair(x0, x1), y1) → HEADACTIVE(afterNthActive(pair(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, U21(x0, x1), y1) → SNDACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
MARK(fst(afterNth(x0, x1))) → FSTACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U31(take(x0, x1), y1)) → U31ACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(and(U11(x0, x1, x2), y1)) → ANDACTIVE(U11Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U61(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U61Active(mark(x0), x1)))
TAKEACTIVE(N, XS) → ISNATURALACTIVE(N)
MARK(splitAt(and(x0, x1), y1)) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, sel(x0, x1), y1) → HEADACTIVE(afterNthActive(selActive(mark(x0), mark(x1)), mark(y1)))
U101ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, U11(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
MARK(U41(U61(x0, x1), y1)) → U41ACTIVE(U61Active(mark(x0), x1), y1)
U41ACTIVE(tt, N) → MARK(N)
U101ACTIVE(tt, natsFrom(x0), y1) → FSTACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U41(U21(x0, x1), y1)) → U41ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U71(U41(x0, x1), y1)) → U71ACTIVE(U41Active(mark(x0), x1), y1)
MARK(tail(take(x0, x1))) → TAILACTIVE(takeActive(mark(x0), mark(x1)))
MARK(tail(and(x0, x1))) → TAILACTIVE(andActive(mark(x0), x1))
U11ACTIVE(tt, y0, take(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
U11ACTIVE(tt, cons(x0, x1), y1) → SNDACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
ISLNATACTIVE(tail(V1)) → ISLNATACTIVE(V1)
MARK(and(splitAt(x0, x1), y1)) → ANDACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U11(U61(x0, x1), y1, y2)) → U11ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(snd(U71(x0, x1))) → SNDACTIVE(U71Active(mark(x0), x1))
MARK(U81(fst(x0), y1, y2, y3)) → U81ACTIVE(fstActive(mark(x0)), y1, y2, y3)
MARK(tail(U91(x0, x1))) → TAILACTIVE(U91Active(mark(x0), x1))
U101ACTIVE(tt, U101(x0, x1, x2), y1) → FSTACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
U51ACTIVE(tt, U51(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(and(take(x0, x1), y1)) → ANDACTIVE(takeActive(mark(x0), mark(x1)), y1)
MARK(U101(snd(x0), y1, y2)) → U101ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(and(U71(x0, x1), y1)) → ANDACTIVE(U71Active(mark(x0), x1), y1)
MARK(fst(U61(x0, x1))) → FSTACTIVE(U61Active(mark(x0), x1))
MARK(U51(fst(x0), y1, y2)) → U51ACTIVE(fstActive(mark(x0)), y1, y2)
MARK(head(splitAt(x0, x1))) → HEADACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U11(U82(x0, x1), y1, y2)) → U11ACTIVE(U82Active(mark(x0), x1), y1, y2)
MARK(isNatural(x1)) → ISNATURALACTIVE(x1)
MARK(U31(isLNat(x0), y1)) → U31ACTIVE(isLNatActive(x0), y1)
MARK(splitAt(U91(x0, x1), y1)) → SPLITATACTIVE(U91Active(mark(x0), x1), mark(y1))
U101ACTIVE(tt, y0, tt) → FSTACTIVE(splitAtActive(mark(y0), tt))
U101ACTIVE(tt, tt, y1) → FSTACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, snd(x0), y1) → SPLITATACTIVE(sndActive(mark(x0)), mark(y1))
MARK(U82(tail(x0), y1)) → U82ACTIVE(tailActive(mark(x0)), y1)
U82ACTIVE(pair(YS, ZS), X) → MARK(ZS)
MARK(snd(U61(x0, x1))) → SNDACTIVE(U61Active(mark(x0), x1))
U11ACTIVE(tt, y0, U51(x0, x1, x2)) → SNDACTIVE(splitAtActive(mark(y0), U51Active(mark(x0), x1, x2)))
MARK(isLNat(x1)) → ISLNATACTIVE(x1)
U51ACTIVE(tt, y0, head(x0)) → HEADACTIVE(afterNthActive(mark(y0), headActive(mark(x0))))
MARK(fst(U81(x0, x1, x2, x3))) → FSTACTIVE(U81Active(mark(x0), x1, x2, x3))
U101ACTIVE(tt, y0, U21(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U21Active(mark(x0), x1)))
MARK(and(tail(x0), y1)) → ANDACTIVE(tailActive(mark(x0)), y1)
MARK(U61(U91(x0, x1), y1)) → U61ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
MARK(U101(and(x0, x1), y1, y2)) → U101ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(U41(afterNth(x0, x1), y1)) → U41ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(sel(x0, x1), y1)) → U41ACTIVE(selActive(mark(x0), mark(x1)), y1)
U11ACTIVE(tt, nil, y1) → SNDACTIVE(splitAtActive(nil, mark(y1)))
U11ACTIVE(tt, y0, nil) → SNDACTIVE(splitAtActive(mark(y0), nil))
MARK(U31(tt, y1)) → U31ACTIVE(tt, y1)
MARK(and(head(x0), y1)) → ANDACTIVE(headActive(mark(x0)), y1)
U51ACTIVE(tt, N, XS) → MARK(N)
ISNATURALACTIVE(sel(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, natsFrom(x0)) → SNDACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
MARK(splitAt(isPLNat(x0), y1)) → SPLITATACTIVE(isPLNatActive(x0), mark(y1))
U11ACTIVE(tt, U82(x0, x1), y1) → SNDACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
MARK(U21(U11(x0, x1, x2), y1)) → U21ACTIVE(U11Active(mark(x0), x1, x2), y1)
U101ACTIVE(tt, tail(x0), y1) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
MARK(fst(and(x0, x1))) → FSTACTIVE(andActive(mark(x0), x1))
U101ACTIVE(tt, snd(x0), y1) → FSTACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U51(x1, x2, x3)) → MARK(x1)
MARK(and(U61(x0, x1), y1)) → ANDACTIVE(U61Active(mark(x0), x1), y1)
MARK(U11(tail(x0), y1, y2)) → U11ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(U41(U41(x0, x1), y1)) → U41ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U11(splitAt(x0, x1), y1, y2)) → U11ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
MARK(U11(x1, x2, x3)) → MARK(x1)
U101ACTIVE(tt, y0, U82(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U21(tail(x0), y1)) → U21ACTIVE(tailActive(mark(x0)), y1)
MARK(splitAt(x1, x2)) → MARK(x1)
MARK(tail(cons(x0, x1))) → TAILACTIVE(cons(mark(x0), x1))
MARK(U71(U11(x0, x1, x2), y1)) → U71ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(snd(and(x0, x1))) → SNDACTIVE(andActive(mark(x0), x1))
MARK(snd(sel(x0, x1))) → SNDACTIVE(selActive(mark(x0), mark(x1)))
MARK(U21(isNatural(x0), y1)) → U21ACTIVE(isNaturalActive(x0), y1)
U101ACTIVE(tt, y0, isLNat(x0)) → FSTACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(U71(U21(x0, x1), y1)) → U71ACTIVE(U21Active(mark(x0), x1), y1)
MARK(fst(isLNat(x0))) → FSTACTIVE(isLNatActive(x0))
MARK(U81(U81(x0, x1, x2, x3), y1, y2, y3)) → U81ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2, y3)
MARK(fst(natsFrom(x0))) → FSTACTIVE(natsFromActive(mark(x0)))
MARK(fst(U41(x0, x1))) → FSTACTIVE(U41Active(mark(x0), x1))
U101ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
U101ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
U101ACTIVE(tt, sel(x0, x1), y1) → FSTACTIVE(splitAtActive(selActive(mark(x0), mark(x1)), mark(y1)))
MARK(U11(U41(x0, x1), y1, y2)) → U11ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U91(natsFrom(x0), y1)) → U91ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U81(head(x0), y1, y2, y3)) → U81ACTIVE(headActive(mark(x0)), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SNDACTIVE(splitAtActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
ISPLNATACTIVE(pair(tail(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
ISNATURALACTIVE(sel(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U82(U31(x0, x1), y1)) → U82ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U71(afterNth(x0, x1), y1)) → U71ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
U51ACTIVE(tt, y0, snd(x0)) → HEADACTIVE(afterNthActive(mark(y0), sndActive(mark(x0))))
U101ACTIVE(tt, isLNat(x0), y1) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
ISPLNATACTIVE(pair(afterNth(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U51ACTIVE(tt, snd(x0), y1) → HEADACTIVE(afterNthActive(sndActive(mark(x0)), mark(y1)))
U101ACTIVE(tt, afterNth(x0, x1), y1) → SPLITATACTIVE(afterNthActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, natsFrom(x0), y1) → HEADACTIVE(afterNthActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U41(snd(x0), y1)) → U41ACTIVE(sndActive(mark(x0)), y1)
U11ACTIVE(tt, U82(x0, x1), y1) → SPLITATACTIVE(U82Active(mark(x0), x1), mark(y1))
MARK(U71(U71(x0, x1), y1)) → U71ACTIVE(U71Active(mark(x0), x1), y1)
AFTERNTHACTIVE(N, XS) → ISNATURALACTIVE(N)
U51ACTIVE(tt, y0, s(x0)) → HEADACTIVE(afterNthActive(mark(y0), s(mark(x0))))
U51ACTIVE(tt, take(x0, x1), y1) → HEADACTIVE(afterNthActive(takeActive(mark(x0), mark(x1)), mark(y1)))
U11ACTIVE(tt, tt, y1) → SNDACTIVE(splitAtActive(tt, mark(y1)))
U11ACTIVE(tt, y0, tt) → SNDACTIVE(splitAtActive(mark(y0), tt))
MARK(U51(isPLNat(x0), y1, y2)) → U51ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U82(and(x0, x1), y1)) → U82ACTIVE(andActive(mark(x0), x1), y1)
MARK(U51(splitAt(x0, x1), y1, y2)) → U51ACTIVE(splitAtActive(mark(x0), mark(x1)), y1, y2)
U21ACTIVE(tt, X) → MARK(X)
MARK(U41(U101(x0, x1, x2), y1)) → U41ACTIVE(U101Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, y0, U82(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U82Active(mark(x0), x1)))
MARK(snd(U82(x0, x1))) → SNDACTIVE(U82Active(mark(x0), x1))
MARK(fst(isPLNat(x0))) → FSTACTIVE(isPLNatActive(x0))
MARK(U11(take(x0, x1), y1, y2)) → U11ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(s(x1)) → MARK(x1)
U51ACTIVE(tt, U101(x0, x1, x2), y1) → HEADACTIVE(afterNthActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U81(U61(x0, x1), y1, y2, y3)) → U81ACTIVE(U61Active(mark(x0), x1), y1, y2, y3)
MARK(U51(U61(x0, x1), y1, y2)) → U51ACTIVE(U61Active(mark(x0), x1), y1, y2)
MARK(U21(snd(x0), y1)) → U21ACTIVE(sndActive(mark(x0)), y1)
U51ACTIVE(tt, y0, tail(x0)) → HEADACTIVE(afterNthActive(mark(y0), tailActive(mark(x0))))
U11ACTIVE(tt, s(x0), y1) → SPLITATACTIVE(s(mark(x0)), mark(y1))
ISLNATACTIVE(afterNth(V1, V2)) → ISNATURALACTIVE(V1)
MARK(tail(U82(x0, x1))) → TAILACTIVE(U82Active(mark(x0), x1))
ISNATURALACTIVE(sel(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U101ACTIVE(tt, y0, natsFrom(x0)) → FSTACTIVE(splitAtActive(mark(y0), natsFromActive(mark(x0))))
MARK(snd(head(x0))) → SNDACTIVE(headActive(mark(x0)))
MARK(U61(tail(x0), y1)) → U61ACTIVE(tailActive(mark(x0)), y1)
ISLNATACTIVE(take(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
SNDACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(head(snd(x0))) → HEADACTIVE(sndActive(mark(x0)))
MARK(splitAt(U61(x0, x1), y1)) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
U101ACTIVE(tt, U41(x0, x1), y1) → FSTACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
MARK(U41(natsFrom(x0), y1)) → U41ACTIVE(natsFromActive(mark(x0)), y1)
ISPLNATACTIVE(splitAt(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
AFTERNTHACTIVE(N, XS) → U11ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
U51ACTIVE(tt, N, XS) → AFTERNTHACTIVE(mark(N), mark(XS))
MARK(U11(U91(x0, x1), y1, y2)) → U11ACTIVE(U91Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, U91(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U91Active(mark(x0), x1)))
U11ACTIVE(tt, y0, U81(x0, x1, x2, x3)) → SNDACTIVE(splitAtActive(mark(y0), U81Active(mark(x0), x1, x2, x3)))
MARK(sel(x1, x2)) → SELACTIVE(mark(x1), mark(x2))
MARK(U21(U71(x0, x1), y1)) → U21ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U101(take(x0, x1), y1, y2)) → U101ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2)
MARK(U82(U82(x0, x1), y1)) → U82ACTIVE(U82Active(mark(x0), x1), y1)
MARK(U21(U61(x0, x1), y1)) → U21ACTIVE(U61Active(mark(x0), x1), y1)
MARK(U21(U41(x0, x1), y1)) → U21ACTIVE(U41Active(mark(x0), x1), y1)
MARK(U21(U31(x0, x1), y1)) → U21ACTIVE(U31Active(mark(x0), x1), y1)
MARK(U11(head(x0), y1, y2)) → U11ACTIVE(headActive(mark(x0)), y1, y2)
U101ACTIVE(tt, U51(x0, x1, x2), y1) → FSTACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
MARK(U71(tail(x0), y1)) → U71ACTIVE(tailActive(mark(x0)), y1)
MARK(pair(x1, x2)) → MARK(x1)
U11ACTIVE(tt, snd(x0), y1) → SNDACTIVE(splitAtActive(sndActive(mark(x0)), mark(y1)))
MARK(U81(U71(x0, x1), y1, y2, y3)) → U81ACTIVE(U71Active(mark(x0), x1), y1, y2, y3)
U51ACTIVE(tt, y0, U82(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U82Active(mark(x0), x1)))
MARK(U51(tail(x0), y1, y2)) → U51ACTIVE(tailActive(mark(x0)), y1, y2)
MARK(head(and(x0, x1))) → HEADACTIVE(andActive(mark(x0), x1))
U11ACTIVE(tt, take(x0, x1), y1) → SPLITATACTIVE(takeActive(mark(x0), mark(x1)), mark(y1))
U51ACTIVE(tt, y0, natsFrom(x0)) → HEADACTIVE(afterNthActive(mark(y0), natsFromActive(mark(x0))))
MARK(U82(U61(x0, x1), y1)) → U82ACTIVE(U61Active(mark(x0), x1), y1)
U11ACTIVE(tt, and(x0, x1), y1) → SPLITATACTIVE(andActive(mark(x0), x1), mark(y1))
U51ACTIVE(tt, N, XS) → MARK(XS)
MARK(splitAt(sel(x0, x1), y1)) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U81(take(x0, x1), y1, y2, y3)) → U81ACTIVE(takeActive(mark(x0), mark(x1)), y1, y2, y3)
U51ACTIVE(tt, y0, pair(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), pair(mark(x0), mark(x1))))
U11ACTIVE(tt, y0, isLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isLNatActive(x0)))
MARK(tail(fst(x0))) → TAILACTIVE(fstActive(mark(x0)))
U11ACTIVE(tt, U51(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U51Active(mark(x0), x1, x2), mark(y1)))
U51ACTIVE(tt, and(x0, x1), y1) → HEADACTIVE(afterNthActive(andActive(mark(x0), x1), mark(y1)))
MARK(U82(U21(x0, x1), y1)) → U82ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U21(U81(x0, x1, x2, x3), y1)) → U21ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U91(isLNat(x0), y1)) → U91ACTIVE(isLNatActive(x0), y1)
MARK(head(U21(x0, x1))) → HEADACTIVE(U21Active(mark(x0), x1))
MARK(pair(x1, x2)) → MARK(x2)
MARK(U81(U11(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U11Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U51(U11(x0, x1, x2), y1, y2)) → U51ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
HEADACTIVE(cons(N, XS)) → ISNATURALACTIVE(N)
U11ACTIVE(tt, s(x0), y1) → SNDACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
U51ACTIVE(tt, isPLNat(x0), y1) → HEADACTIVE(afterNthActive(isPLNatActive(x0), mark(y1)))
MARK(U71(U82(x0, x1), y1)) → U71ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SNDACTIVE(splitAtActive(U81Active(mark(x0), x1, x2, x3), mark(y1)))
MARK(U11(and(x0, x1), y1, y2)) → U11ACTIVE(andActive(mark(x0), x1), y1, y2)
MARK(and(afterNth(x0, x1), y1)) → ANDACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U41(isLNat(x0), y1)) → U41ACTIVE(isLNatActive(x0), y1)
MARK(U41(U51(x0, x1, x2), y1)) → U41ACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(U31(isPLNat(x0), y1)) → U31ACTIVE(isPLNatActive(x0), y1)
MARK(tail(splitAt(x0, x1))) → TAILACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(U31(U81(x0, x1, x2, x3), y1)) → U31ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
MARK(U51(snd(x0), y1, y2)) → U51ACTIVE(sndActive(mark(x0)), y1, y2)
MARK(U81(snd(x0), y1, y2, y3)) → U81ACTIVE(sndActive(mark(x0)), y1, y2, y3)
MARK(U71(tt, y1)) → U71ACTIVE(tt, y1)
U51ACTIVE(tt, isLNat(x0), y1) → HEADACTIVE(afterNthActive(isLNatActive(x0), mark(y1)))
U51ACTIVE(tt, fst(x0), y1) → HEADACTIVE(afterNthActive(fstActive(mark(x0)), mark(y1)))
MARK(snd(splitAt(x0, x1))) → SNDACTIVE(splitAtActive(mark(x0), mark(x1)))
MARK(tail(U61(x0, x1))) → TAILACTIVE(U61Active(mark(x0), x1))
ISLNATACTIVE(take(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
MARK(U61(U81(x0, x1, x2, x3), y1)) → U61ACTIVE(U81Active(mark(x0), x1, x2, x3), y1)
U51ACTIVE(tt, y0, sel(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), selActive(mark(x0), mark(x1))))
MARK(fst(sel(x0, x1))) → FSTACTIVE(selActive(mark(x0), mark(x1)))
ISPLNATACTIVE(splitAt(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, natsFrom(x0), y1) → SNDACTIVE(splitAtActive(natsFromActive(mark(x0)), mark(y1)))
MARK(U11(snd(x0), y1, y2)) → U11ACTIVE(sndActive(mark(x0)), y1, y2)
U11ACTIVE(tt, U71(x0, x1), y1) → SNDACTIVE(splitAtActive(U71Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
MARK(U11(natsFrom(x0), y1, y2)) → U11ACTIVE(natsFromActive(mark(x0)), y1, y2)
U71ACTIVE(tt, XS) → MARK(XS)
MARK(U41(splitAt(x0, x1), y1)) → U41ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
U101ACTIVE(tt, and(x0, x1), y1) → FSTACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, y0, fst(x0)) → FSTACTIVE(splitAtActive(mark(y0), fstActive(mark(x0))))
MARK(U41(tail(x0), y1)) → U41ACTIVE(tailActive(mark(x0)), y1)
U101ACTIVE(tt, y0, nil) → FSTACTIVE(splitAtActive(mark(y0), nil))
U101ACTIVE(tt, nil, y1) → FSTACTIVE(splitAtActive(nil, mark(y1)))
MARK(take(x1, x2)) → MARK(x2)
MARK(U21(U82(x0, x1), y1)) → U21ACTIVE(U82Active(mark(x0), x1), y1)
U11ACTIVE(tt, y0, snd(x0)) → SNDACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
ISPLNATACTIVE(pair(fst(x0), y1)) → ANDACTIVE(isPLNatActive(x0), isLNat(y1))
SELACTIVE(N, XS) → ISNATURALACTIVE(N)
U101ACTIVE(tt, y0, afterNth(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
TAKEACTIVE(N, XS) → U101ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U61(afterNth(x0, x1), y1)) → U61ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(tail(U41(x0, x1))) → TAILACTIVE(U41Active(mark(x0), x1))
ISNATURALACTIVE(head(V1)) → ISLNATACTIVE(V1)
MARK(U101(U31(x0, x1), y1, y2)) → U101ACTIVE(U31Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, head(x0), y1) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
MARK(U11(isLNat(x0), y1, y2)) → U11ACTIVE(isLNatActive(x0), y1, y2)
MARK(U71(snd(x0), y1)) → U71ACTIVE(sndActive(mark(x0)), y1)
U101ACTIVE(tt, cons(x0, x1), y1) → FSTACTIVE(splitAtActive(cons(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, isLNat(x0), y1) → FSTACTIVE(splitAtActive(isLNatActive(x0), mark(y1)))
MARK(U41(U82(x0, x1), y1)) → U41ACTIVE(U82Active(mark(x0), x1), y1)
MARK(and(U31(x0, x1), y1)) → ANDACTIVE(U31Active(mark(x0), x1), y1)
SPLITATACTIVE(0, XS) → ISLNATACTIVE(XS)
MARK(U82(isLNat(x0), y1)) → U82ACTIVE(isLNatActive(x0), y1)
MARK(U31(U101(x0, x1, x2), y1)) → U31ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(U71(x0, x1), y1)) → U82ACTIVE(U71Active(mark(x0), x1), y1)
TAILACTIVE(cons(N, XS)) → U91ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), XS)
MARK(fst(U31(x0, x1))) → FSTACTIVE(U31Active(mark(x0), x1))
U11ACTIVE(tt, U101(x0, x1, x2), y1) → SNDACTIVE(splitAtActive(U101Active(mark(x0), x1, x2), mark(y1)))
MARK(U61(isLNat(x0), y1)) → U61ACTIVE(isLNatActive(x0), y1)
MARK(fst(U91(x0, x1))) → FSTACTIVE(U91Active(mark(x0), x1))
MARK(U91(U11(x0, x1, x2), y1)) → U91ACTIVE(U11Active(mark(x0), x1, x2), y1)
MARK(U91(head(x0), y1)) → U91ACTIVE(headActive(mark(x0)), y1)
U101ACTIVE(tt, U61(x0, x1), y1) → SPLITATACTIVE(U61Active(mark(x0), x1), mark(y1))
MARK(and(U41(x0, x1), y1)) → ANDACTIVE(U41Active(mark(x0), x1), y1)
U51ACTIVE(tt, y0, U31(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U31Active(mark(x0), x1)))
MARK(snd(take(x0, x1))) → SNDACTIVE(takeActive(mark(x0), mark(x1)))
MARK(U71(isLNat(x0), y1)) → U71ACTIVE(isLNatActive(x0), y1)
ISLNATACTIVE(cons(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U101ACTIVE(tt, N, XS) → MARK(N)
MARK(U21(isLNat(x0), y1)) → U21ACTIVE(isLNatActive(x0), y1)
MARK(U21(U51(x0, x1, x2), y1)) → U21ACTIVE(U51Active(mark(x0), x1, x2), y1)
U101ACTIVE(tt, y0, U31(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), U31Active(mark(x0), x1)))
MARK(splitAt(U81(x0, x1, x2, x3), y1)) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U51ACTIVE(tt, isNatural(x0), y1) → HEADACTIVE(afterNthActive(isNaturalActive(x0), mark(y1)))
MARK(U41(tt, y1)) → U41ACTIVE(tt, y1)
MARK(U61(sel(x0, x1), y1)) → U61ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(and(tt, y1)) → ANDACTIVE(tt, y1)
U11ACTIVE(tt, y0, tail(x0)) → SNDACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(U101(U41(x0, x1), y1, y2)) → U101ACTIVE(U41Active(mark(x0), x1), y1, y2)
MARK(U81(U82(x0, x1), y1, y2, y3)) → U81ACTIVE(U82Active(mark(x0), x1), y1, y2, y3)
U101ACTIVE(tt, y0, tail(x0)) → FSTACTIVE(splitAtActive(mark(y0), tailActive(mark(x0))))
MARK(snd(tail(x0))) → SNDACTIVE(tailActive(mark(x0)))
MARK(sel(x1, x2)) → MARK(x1)
U11ACTIVE(tt, y0, U71(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), U71Active(mark(x0), x1)))
MARK(tail(sel(x0, x1))) → TAILACTIVE(selActive(mark(x0), mark(x1)))
MARK(fst(U51(x0, x1, x2))) → FSTACTIVE(U51Active(mark(x0), x1, x2))
MARK(afterNth(x1, x2)) → AFTERNTHACTIVE(mark(x1), mark(x2))
MARK(and(sel(x0, x1), y1)) → ANDACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(splitAt(tail(x0), y1)) → SPLITATACTIVE(tailActive(mark(x0)), mark(y1))
TAILACTIVE(cons(N, XS)) → ANDACTIVE(isNaturalActive(N), isLNat(XS))
MARK(U21(tt, y1)) → U21ACTIVE(tt, y1)
U101ACTIVE(tt, fst(x0), y1) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
MARK(U91(x1, x2)) → MARK(x1)
MARK(tail(U11(x0, x1, x2))) → TAILACTIVE(U11Active(mark(x0), x1, x2))
MARK(U21(natsFrom(x0), y1)) → U21ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U82(U51(x0, x1, x2), y1)) → U82ACTIVE(U51Active(mark(x0), x1, x2), y1)
U11ACTIVE(tt, tail(x0), y1) → SNDACTIVE(splitAtActive(tailActive(mark(x0)), mark(y1)))
ISLNATACTIVE(snd(V1)) → ISPLNATACTIVE(V1)
ISLNATACTIVE(afterNth(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U101ACTIVE(tt, y0, take(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), takeActive(mark(x0), mark(x1))))
MARK(U51(U101(x0, x1, x2), y1, y2)) → U51ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
MARK(U82(afterNth(x0, x1), y1)) → U82ACTIVE(afterNthActive(mark(x0), mark(x1)), y1)
MARK(U101(U81(x0, x1, x2, x3), y1, y2)) → U101ACTIVE(U81Active(mark(x0), x1, x2, x3), y1, y2)
U51ACTIVE(tt, y0, afterNth(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), afterNthActive(mark(x0), mark(x1))))
U101ACTIVE(tt, U21(x0, x1), y1) → FSTACTIVE(splitAtActive(U21Active(mark(x0), x1), mark(y1)))
ISNATURALACTIVE(sel(V1, V2)) → ISNATURALACTIVE(V1)
SELACTIVE(N, XS) → U51ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
MARK(U21(U21(x0, x1), y1)) → U21ACTIVE(U21Active(mark(x0), x1), y1)
MARK(natsFrom(x1)) → MARK(x1)
ISLNATACTIVE(afterNth(s(x0), y1)) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
MARK(U101(U21(x0, x1), y1, y2)) → U101ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, y0, isPLNat(x0)) → SNDACTIVE(splitAtActive(mark(y0), isPLNatActive(x0)))
ISNATURALACTIVE(s(V1)) → ISNATURALACTIVE(V1)
U51ACTIVE(tt, y0, fst(x0)) → HEADACTIVE(afterNthActive(mark(y0), fstActive(mark(x0))))
MARK(U51(U51(x0, x1, x2), y1, y2)) → U51ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U101(x1, x2, x3)) → MARK(x1)
ISPLNATACTIVE(splitAt(sel(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U21(isPLNat(x0), y1)) → U21ACTIVE(isPLNatActive(x0), y1)
MARK(fst(U101(x0, x1, x2))) → FSTACTIVE(U101Active(mark(x0), x1, x2))
MARK(snd(isLNat(x0))) → SNDACTIVE(isLNatActive(x0))
MARK(head(afterNth(x0, x1))) → HEADACTIVE(afterNthActive(mark(x0), mark(x1)))
U101ACTIVE(tt, y0, head(x0)) → FSTACTIVE(splitAtActive(mark(y0), headActive(mark(x0))))
MARK(splitAt(s(x0), y1)) → SPLITATACTIVE(s(mark(x0)), mark(y1))
U101ACTIVE(tt, y0, snd(x0)) → FSTACTIVE(splitAtActive(mark(y0), sndActive(mark(x0))))
MARK(snd(U11(x0, x1, x2))) → SNDACTIVE(U11Active(mark(x0), x1, x2))
MARK(U81(tail(x0), y1, y2, y3)) → U81ACTIVE(tailActive(mark(x0)), y1, y2, y3)
MARK(head(U81(x0, x1, x2, x3))) → HEADACTIVE(U81Active(mark(x0), x1, x2, x3))
MARK(U51(sel(x0, x1), y1, y2)) → U51ACTIVE(selActive(mark(x0), mark(x1)), y1, y2)
U101ACTIVE(tt, s(x0), y1) → FSTACTIVE(splitAtActive(s(mark(x0)), mark(y1)))
MARK(and(natsFrom(x0), y1)) → ANDACTIVE(natsFromActive(mark(x0)), y1)
MARK(and(U101(x0, x1, x2), y1)) → ANDACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U21(head(x0), y1)) → U21ACTIVE(headActive(mark(x0)), y1)
MARK(U71(natsFrom(x0), y1)) → U71ACTIVE(natsFromActive(mark(x0)), y1)
MARK(U41(U71(x0, x1), y1)) → U41ACTIVE(U71Active(mark(x0), x1), y1)
MARK(U61(and(x0, x1), y1)) → U61ACTIVE(andActive(mark(x0), x1), y1)
MARK(U11(U101(x0, x1, x2), y1, y2)) → U11ACTIVE(U101Active(mark(x0), x1, x2), y1, y2)
U11ACTIVE(tt, U31(x0, x1), y1) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, y0, pair(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), pair(mark(x0), mark(x1))))
MARK(U71(splitAt(x0, x1), y1)) → U71ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(U31(splitAt(x0, x1), y1)) → U31ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(isPLNat(x1)) → ISPLNATACTIVE(x1)
U11ACTIVE(tt, sel(x0, x1), y1) → SPLITATACTIVE(selActive(mark(x0), mark(x1)), mark(y1))
MARK(U41(fst(x0), y1)) → U41ACTIVE(fstActive(mark(x0)), y1)
MARK(U21(and(x0, x1), y1)) → U21ACTIVE(andActive(mark(x0), x1), y1)
MARK(U81(U31(x0, x1), y1, y2, y3)) → U81ACTIVE(U31Active(mark(x0), x1), y1, y2, y3)
MARK(U101(U11(x0, x1, x2), y1, y2)) → U101ACTIVE(U11Active(mark(x0), x1, x2), y1, y2)
MARK(splitAt(isNatural(x0), y1)) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
MARK(splitAt(head(x0), y1)) → SPLITATACTIVE(headActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, s(x0)) → SNDACTIVE(splitAtActive(mark(y0), s(mark(x0))))
MARK(snd(U41(x0, x1))) → SNDACTIVE(U41Active(mark(x0), x1))
MARK(tail(afterNth(x0, x1))) → TAILACTIVE(afterNthActive(mark(x0), mark(x1)))
MARK(U101(isLNat(x0), y1, y2)) → U101ACTIVE(isLNatActive(x0), y1, y2)
MARK(tail(isLNat(x0))) → TAILACTIVE(isLNatActive(x0))
MARK(U21(U91(x0, x1), y1)) → U21ACTIVE(U91Active(mark(x0), x1), y1)
U11ACTIVE(tt, U41(x0, x1), y1) → SNDACTIVE(splitAtActive(U41Active(mark(x0), x1), mark(y1)))
U101ACTIVE(tt, U91(x0, x1), y1) → FSTACTIVE(splitAtActive(U91Active(mark(x0), x1), mark(y1)))
ISLNATACTIVE(natsFrom(V1)) → ISNATURALACTIVE(V1)
MARK(U81(U21(x0, x1), y1, y2, y3)) → U81ACTIVE(U21Active(mark(x0), x1), y1, y2, y3)
U11ACTIVE(tt, splitAt(x0, x1), y1) → SPLITATACTIVE(splitAtActive(mark(x0), mark(x1)), mark(y1))
FSTACTIVE(pair(X, Y)) → ANDACTIVE(isLNatActive(X), isLNat(Y))
MARK(U101(U51(x0, x1, x2), y1, y2)) → U101ACTIVE(U51Active(mark(x0), x1, x2), y1, y2)
MARK(U61(U41(x0, x1), y1)) → U61ACTIVE(U41Active(mark(x0), x1), y1)
U101ACTIVE(tt, U31(x0, x1), y1) → FSTACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(take(x1, x2)) → TAKEACTIVE(mark(x1), mark(x2))
U51ACTIVE(tt, y0, U41(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), U41Active(mark(x0), x1)))
U11ACTIVE(tt, U31(x0, x1), y1) → SNDACTIVE(splitAtActive(U31Active(mark(x0), x1), mark(y1)))
MARK(U61(x1, x2)) → MARK(x1)
U82ACTIVE(pair(YS, ZS), X) → MARK(X)
AFTERNTHACTIVE(s(x0), y1) → ANDACTIVE(isNaturalActive(x0), isLNat(y1))
U11ACTIVE(tt, 0, y1) → SPLITATACTIVE(0, mark(y1))
U101ACTIVE(tt, U11(x0, x1, x2), y1) → SPLITATACTIVE(U11Active(mark(x0), x1, x2), mark(y1))
U101ACTIVE(tt, U82(x0, x1), y1) → FSTACTIVE(splitAtActive(U82Active(mark(x0), x1), mark(y1)))
MARK(and(U51(x0, x1, x2), y1)) → ANDACTIVE(U51Active(mark(x0), x1, x2), y1)
MARK(sel(x1, x2)) → MARK(x2)
MARK(tail(U101(x0, x1, x2))) → TAILACTIVE(U101Active(mark(x0), x1, x2))
MARK(U82(fst(x0), y1)) → U82ACTIVE(fstActive(mark(x0)), y1)
MARK(U41(head(x0), y1)) → U41ACTIVE(headActive(mark(x0)), y1)
MARK(U61(U101(x0, x1, x2), y1)) → U61ACTIVE(U101Active(mark(x0), x1, x2), y1)
MARK(U82(natsFrom(x0), y1)) → U82ACTIVE(natsFromActive(mark(x0)), y1)
MARK(cons(x1, x2)) → MARK(x1)
MARK(U31(U21(x0, x1), y1)) → U31ACTIVE(U21Active(mark(x0), x1), y1)
MARK(and(U82(x0, x1), y1)) → ANDACTIVE(U82Active(mark(x0), x1), y1)
U101ACTIVE(tt, y0, cons(x0, x1)) → FSTACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
MARK(U11(isPLNat(x0), y1, y2)) → U11ACTIVE(isPLNatActive(x0), y1, y2)
MARK(U61(splitAt(x0, x1), y1)) → U61ACTIVE(splitAtActive(mark(x0), mark(x1)), y1)
MARK(splitAt(fst(x0), y1)) → SPLITATACTIVE(fstActive(mark(x0)), mark(y1))
AFTERNTHACTIVE(sel(x0, x1), y1) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
MARK(U91(isPLNat(x0), y1)) → U91ACTIVE(isPLNatActive(x0), y1)
MARK(U11(U71(x0, x1), y1, y2)) → U11ACTIVE(U71Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, isNatural(x0), y1) → SPLITATACTIVE(isNaturalActive(x0), mark(y1))
HEADACTIVE(cons(N, XS)) → U31ACTIVE(andActive(isNaturalActive(N), isLNat(XS)), N)
MARK(U82(isPLNat(x0), y1)) → U82ACTIVE(isPLNatActive(x0), y1)
MARK(U71(U31(x0, x1), y1)) → U71ACTIVE(U31Active(mark(x0), x1), y1)
FSTACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
ISPLNATACTIVE(pair(V1, V2)) → ISLNATACTIVE(V1)
MARK(U82(U91(x0, x1), y1)) → U82ACTIVE(U91Active(mark(x0), x1), y1)
MARK(splitAt(isLNat(x0), y1)) → SPLITATACTIVE(isLNatActive(x0), mark(y1))
ISPLNATACTIVE(pair(cons(x0, x1), y1)) → ANDACTIVE(andActive(isNaturalActive(x0), isLNat(x1)), isLNat(y1))
U101ACTIVE(tt, y0, isNatural(x0)) → FSTACTIVE(splitAtActive(mark(y0), isNaturalActive(x0)))
U51ACTIVE(tt, y0, cons(x0, x1)) → HEADACTIVE(afterNthActive(mark(y0), cons(mark(x0), x1)))
U11ACTIVE(tt, take(x0, x1), y1) → SNDACTIVE(splitAtActive(takeActive(mark(x0), mark(x1)), mark(y1)))
ISLNATACTIVE(afterNth(0, y1)) → ANDACTIVE(tt, isLNat(y1))
MARK(fst(isNatural(x0))) → FSTACTIVE(isNaturalActive(x0))
U51ACTIVE(tt, splitAt(x0, x1), y1) → HEADACTIVE(afterNthActive(splitAtActive(mark(x0), mark(x1)), mark(y1)))
MARK(and(isPLNat(x0), y1)) → ANDACTIVE(isPLNatActive(x0), y1)
SNDACTIVE(pair(X, Y)) → ISLNATACTIVE(X)
MARK(U81(U51(x0, x1, x2), y1, y2, y3)) → U81ACTIVE(U51Active(mark(x0), x1, x2), y1, y2, y3)
MARK(U71(sel(x0, x1), y1)) → U71ACTIVE(selActive(mark(x0), mark(x1)), y1)
MARK(snd(afterNth(x0, x1))) → SNDACTIVE(afterNthActive(mark(x0), mark(x1)))
U51ACTIVE(tt, cons(x0, x1), y1) → HEADACTIVE(afterNthActive(cons(mark(x0), x1), mark(y1)))
U11ACTIVE(tt, U81(x0, x1, x2, x3), y1) → SPLITATACTIVE(U81Active(mark(x0), x1, x2, x3), mark(y1))
U51ACTIVE(tt, y0, isPLNat(x0)) → HEADACTIVE(afterNthActive(mark(y0), isPLNatActive(x0)))
MARK(tail(natsFrom(x0))) → TAILACTIVE(natsFromActive(mark(x0)))
U101ACTIVE(tt, y0, U11(x0, x1, x2)) → FSTACTIVE(splitAtActive(mark(y0), U11Active(mark(x0), x1, x2)))
MARK(splitAt(U31(x0, x1), y1)) → SPLITATACTIVE(U31Active(mark(x0), x1), mark(y1))
MARK(splitAt(U51(x0, x1, x2), y1)) → SPLITATACTIVE(U51Active(mark(x0), x1, x2), mark(y1))
MARK(U61(snd(x0), y1)) → U61ACTIVE(sndActive(mark(x0)), y1)
MARK(U91(U21(x0, x1), y1)) → U91ACTIVE(U21Active(mark(x0), x1), y1)
MARK(U82(take(x0, x1), y1)) → U82ACTIVE(takeActive(mark(x0), mark(x1)), y1)
SPLITATACTIVE(s(N), cons(X, XS)) → ISNATURALACTIVE(N)
MARK(and(isLNat(x0), y1)) → ANDACTIVE(isLNatActive(x0), y1)
U101ACTIVE(tt, U101(x0, x1, x2), y1) → SPLITATACTIVE(U101Active(mark(x0), x1, x2), mark(y1))
ISLNATACTIVE(cons(head(x0), y1)) → ANDACTIVE(isLNatActive(x0), isLNat(y1))
U11ACTIVE(tt, y0, splitAt(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), splitAtActive(mark(x0), mark(x1))))
MARK(U81(isNatural(x0), y1, y2, y3)) → U81ACTIVE(isNaturalActive(x0), y1, y2, y3)
MARK(U11(U21(x0, x1), y1, y2)) → U11ACTIVE(U21Active(mark(x0), x1), y1, y2)
U11ACTIVE(tt, natsFrom(x0), y1) → SPLITATACTIVE(natsFromActive(mark(x0)), mark(y1))
U11ACTIVE(tt, y0, cons(x0, x1)) → SNDACTIVE(splitAtActive(mark(y0), cons(mark(x0), x1)))
U101ACTIVE(tt, U41(x0, x1), y1) → SPLITATACTIVE(U41Active(mark(x0), x1), mark(y1))
MARK(U81(sel(x0, x1), y1, y2, y3)) → U81ACTIVE(selActive(mark(x0), mark(x1)), y1, y2, y3)
ISPLNATACTIVE(splitAt(0, y1)) → ANDACTIVE(tt, isLNat(y1))
U11ACTIVE(tt, U71(x0, x1), y1) → SPLITATACTIVE(U71Active(mark(x0), x1), mark(y1))
U11ACTIVE(tt, and(x0, x1), y1) → SNDACTIVE(splitAtActive(andActive(mark(x0), x1), mark(y1)))
MARK(U71(isPLNat(x0), y1)) → U71ACTIVE(isPLNatActive(x0), y1)
MARK(U81(and(x0, x1), y1, y2, y3)) → U81ACTIVE(andActive(mark(x0), x1), y1, y2, y3)
MARK(tail(head(x0))) → TAILACTIVE(headActive(mark(x0)))

The TRS R consists of the following rules:

mark(U101(x1, x2, x3)) → U101Active(mark(x1), x2, x3)
U101Active(x1, x2, x3) → U101(x1, x2, x3)
mark(U11(x1, x2, x3)) → U11Active(mark(x1), x2, x3)
U11Active(x1, x2, x3) → U11(x1, x2, x3)
mark(U21(x1, x2)) → U21Active(mark(x1), x2)
U21Active(x1, x2) → U21(x1, x2)
mark(U31(x1, x2)) → U31Active(mark(x1), x2)
U31Active(x1, x2) → U31(x1, x2)
mark(U41(x1, x2)) → U41Active(mark(x1), x2)
U41Active(x1, x2) → U41(x1, x2)
mark(U51(x1, x2, x3)) → U51Active(mark(x1), x2, x3)
U51Active(x1, x2, x3) → U51(x1, x2, x3)
mark(U61(x1, x2)) → U61Active(mark(x1), x2)
U61Active(x1, x2) → U61(x1, x2)
mark(U71(x1, x2)) → U71Active(mark(x1), x2)
U71Active(x1, x2) → U71(x1, x2)
mark(U81(x1, x2, x3, x4)) → U81Active(mark(x1), x2, x3, x4)
U81Active(x1, x2, x3, x4) → U81(x1, x2, x3, x4)
mark(U82(x1, x2)) → U82Active(mark(x1), x2)
U82Active(x1, x2) → U82(x1, x2)
mark(U91(x1, x2)) → U91Active(mark(x1), x2)
U91Active(x1, x2) → U91(x1, x2)
mark(afterNth(x1, x2)) → afterNthActive(mark(x1), mark(x2))
afterNthActive(x1, x2) → afterNth(x1, x2)
mark(and(x1, x2)) → andActive(mark(x1), x2)
andActive(x1, x2) → and(x1, x2)
mark(fst(x1)) → fstActive(mark(x1))
fstActive(x1) → fst(x1)
mark(head(x1)) → headActive(mark(x1))
headActive(x1) → head(x1)
mark(isLNat(x1)) → isLNatActive(x1)
isLNatActive(x1) → isLNat(x1)
mark(isNatural(x1)) → isNaturalActive(x1)
isNaturalActive(x1) → isNatural(x1)
mark(isPLNat(x1)) → isPLNatActive(x1)
isPLNatActive(x1) → isPLNat(x1)
mark(natsFrom(x1)) → natsFromActive(mark(x1))
natsFromActive(x1) → natsFrom(x1)
mark(sel(x1, x2)) → selActive(mark(x1), mark(x2))
selActive(x1, x2) → sel(x1, x2)
mark(snd(x1)) → sndActive(mark(x1))
sndActive(x1) → snd(x1)
mark(splitAt(x1, x2)) → splitAtActive(mark(x1), mark(x2))
splitAtActive(x1, x2) → splitAt(x1, x2)
mark(tail(x1)) → tailActive(mark(x1))
tailActive(x1) → tail(x1)
mark(take(x1, x2)) → takeActive(mark(x1), mark(x2))
takeActive(x1, x2) → take(x1, x2)
mark(tt) → tt
mark(cons(x1, x2)) → cons(mark(x1), x2)
mark(s(x1)) → s(mark(x1))
mark(pair(x1, x2)) → pair(mark(x1), mark(x2))
mark(nil) → nil
mark(0) → 0
U101Active(tt, N, XS) → fstActive(splitAtActive(mark(N), mark(XS)))
U11Active(tt, N, XS) → sndActive(splitAtActive(mark(N), mark(XS)))
U21Active(tt, X) → mark(X)
U31Active(tt, N) → mark(N)
U41Active(tt, N) → cons(mark(N), natsFrom(s(N)))
U51Active(tt, N, XS) → headActive(afterNthActive(mark(N), mark(XS)))
U61Active(tt, Y) → mark(Y)
U71Active(tt, XS) → pair(nil, mark(XS))
U81Active(tt, N, X, XS) → U82Active(splitAtActive(mark(N), mark(XS)), X)
U82Active(pair(YS, ZS), X) → pair(cons(mark(X), YS), mark(ZS))
U91Active(tt, XS) → mark(XS)
afterNthActive(N, XS) → U11Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
andActive(tt, X) → mark(X)
fstActive(pair(X, Y)) → U21Active(andActive(isLNatActive(X), isLNat(Y)), X)
headActive(cons(N, XS)) → U31Active(andActive(isNaturalActive(N), isLNat(XS)), N)
isLNatActive(nil) → tt
isLNatActive(afterNth(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(cons(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isLNatActive(fst(V1)) → isPLNatActive(V1)
isLNatActive(natsFrom(V1)) → isNaturalActive(V1)
isLNatActive(snd(V1)) → isPLNatActive(V1)
isLNatActive(tail(V1)) → isLNatActive(V1)
isLNatActive(take(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isNaturalActive(0) → tt
isNaturalActive(head(V1)) → isLNatActive(V1)
isNaturalActive(s(V1)) → isNaturalActive(V1)
isNaturalActive(sel(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
isPLNatActive(pair(V1, V2)) → andActive(isLNatActive(V1), isLNat(V2))
isPLNatActive(splitAt(V1, V2)) → andActive(isNaturalActive(V1), isLNat(V2))
natsFromActive(N) → U41Active(isNaturalActive(N), N)
selActive(N, XS) → U51Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)
sndActive(pair(X, Y)) → U61Active(andActive(isLNatActive(X), isLNat(Y)), Y)
splitAtActive(0, XS) → U71Active(isLNatActive(XS), XS)
splitAtActive(s(N), cons(X, XS)) → U81Active(andActive(isNaturalActive(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tailActive(cons(N, XS)) → U91Active(andActive(isNaturalActive(N), isLNat(XS)), XS)
takeActive(N, XS) → U101Active(andActive(isNaturalActive(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We applied the Trivial transformation to transform the context-sensitive TRS to a usual TRS.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

U101(tt, N, XS) → fst(splitAt(N, XS))
U11(tt, N, XS) → snd(splitAt(N, XS))
U21(tt, X) → X
U31(tt, N) → N
U41(tt, N) → cons(N, natsFrom(s(N)))
U51(tt, N, XS) → head(afterNth(N, XS))
U61(tt, Y) → Y
U71(tt, XS) → pair(nil, XS)
U81(tt, N, X, XS) → U82(splitAt(N, XS), X)
U82(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
U91(tt, XS) → XS
afterNth(N, XS) → U11(and(isNatural(N), isLNat(XS)), N, XS)
and(tt, X) → X
fst(pair(X, Y)) → U21(and(isLNat(X), isLNat(Y)), X)
head(cons(N, XS)) → U31(and(isNatural(N), isLNat(XS)), N)
isLNat(nil) → tt
isLNat(afterNth(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(cons(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(fst(V1)) → isPLNat(V1)
isLNat(natsFrom(V1)) → isNatural(V1)
isLNat(snd(V1)) → isPLNat(V1)
isLNat(tail(V1)) → isLNat(V1)
isLNat(take(V1, V2)) → and(isNatural(V1), isLNat(V2))
isNatural(0) → tt
isNatural(head(V1)) → isLNat(V1)
isNatural(s(V1)) → isNatural(V1)
isNatural(sel(V1, V2)) → and(isNatural(V1), isLNat(V2))
isPLNat(pair(V1, V2)) → and(isLNat(V1), isLNat(V2))
isPLNat(splitAt(V1, V2)) → and(isNatural(V1), isLNat(V2))
natsFrom(N) → U41(isNatural(N), N)
sel(N, XS) → U51(and(isNatural(N), isLNat(XS)), N, XS)
snd(pair(X, Y)) → U61(and(isLNat(X), isLNat(Y)), Y)
splitAt(0, XS) → U71(isLNat(XS), XS)
splitAt(s(N), cons(X, XS)) → U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tail(cons(N, XS)) → U91(and(isNatural(N), isLNat(XS)), XS)
take(N, XS) → U101(and(isNatural(N), isLNat(XS)), N, XS)

Q is empty.

Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

ISLNAT(cons(V1, V2)) → ISNATURAL(V1)
SPLITAT(s(N), cons(X, XS)) → AND(isNatural(N), and(isNatural(X), isLNat(XS)))
SEL(N, XS) → U511(and(isNatural(N), isLNat(XS)), N, XS)
TAKE(N, XS) → ISLNAT(XS)
U511(tt, N, XS) → AFTERNTH(N, XS)
ISLNAT(cons(V1, V2)) → ISLNAT(V2)
AFTERNTH(N, XS) → U111(and(isNatural(N), isLNat(XS)), N, XS)
U1011(tt, N, XS) → SPLITAT(N, XS)
TAIL(cons(N, XS)) → U911(and(isNatural(N), isLNat(XS)), XS)
ISPLNAT(splitAt(V1, V2)) → AND(isNatural(V1), isLNat(V2))
SPLITAT(s(N), cons(X, XS)) → ISNATURAL(X)
NATSFROM(N) → ISNATURAL(N)
TAKE(N, XS) → U1011(and(isNatural(N), isLNat(XS)), N, XS)
SPLITAT(0, XS) → U711(isLNat(XS), XS)
AFTERNTH(N, XS) → AND(isNatural(N), isLNat(XS))
TAKE(N, XS) → ISNATURAL(N)
FST(pair(X, Y)) → U211(and(isLNat(X), isLNat(Y)), X)
ISNATURAL(sel(V1, V2)) → ISNATURAL(V1)
ISPLNAT(pair(V1, V2)) → ISLNAT(V2)
TAKE(N, XS) → AND(isNatural(N), isLNat(XS))
U811(tt, N, X, XS) → SPLITAT(N, XS)
SPLITAT(s(N), cons(X, XS)) → U811(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS)
U511(tt, N, XS) → HEAD(afterNth(N, XS))
ISLNAT(take(V1, V2)) → AND(isNatural(V1), isLNat(V2))
ISLNAT(snd(V1)) → ISPLNAT(V1)
U111(tt, N, XS) → SPLITAT(N, XS)
ISNATURAL(s(V1)) → ISNATURAL(V1)
SND(pair(X, Y)) → AND(isLNat(X), isLNat(Y))
ISPLNAT(pair(V1, V2)) → ISLNAT(V1)
SEL(N, XS) → AND(isNatural(N), isLNat(XS))
HEAD(cons(N, XS)) → ISNATURAL(N)
ISNATURAL(head(V1)) → ISLNAT(V1)
SND(pair(X, Y)) → U611(and(isLNat(X), isLNat(Y)), Y)
SPLITAT(s(N), cons(X, XS)) → AND(isNatural(X), isLNat(XS))
ISLNAT(afterNth(V1, V2)) → AND(isNatural(V1), isLNat(V2))
SND(pair(X, Y)) → ISLNAT(X)
ISNATURAL(sel(V1, V2)) → AND(isNatural(V1), isLNat(V2))
HEAD(cons(N, XS)) → AND(isNatural(N), isLNat(XS))
ISPLNAT(splitAt(V1, V2)) → ISLNAT(V2)
ISLNAT(afterNth(V1, V2)) → ISLNAT(V2)
TAIL(cons(N, XS)) → ISNATURAL(N)
TAIL(cons(N, XS)) → AND(isNatural(N), isLNat(XS))
AFTERNTH(N, XS) → ISLNAT(XS)
SPLITAT(0, XS) → ISLNAT(XS)
U1011(tt, N, XS) → FST(splitAt(N, XS))
HEAD(cons(N, XS)) → ISLNAT(XS)
U411(tt, N) → NATSFROM(s(N))
ISNATURAL(sel(V1, V2)) → ISLNAT(V2)
ISPLNAT(pair(V1, V2)) → AND(isLNat(V1), isLNat(V2))
SEL(N, XS) → ISNATURAL(N)
ISLNAT(natsFrom(V1)) → ISNATURAL(V1)
FST(pair(X, Y)) → ISLNAT(Y)
ISLNAT(fst(V1)) → ISPLNAT(V1)
ISLNAT(cons(V1, V2)) → AND(isNatural(V1), isLNat(V2))
U811(tt, N, X, XS) → U821(splitAt(N, XS), X)
ISLNAT(take(V1, V2)) → ISLNAT(V2)
ISPLNAT(splitAt(V1, V2)) → ISNATURAL(V1)
SEL(N, XS) → ISLNAT(XS)
U111(tt, N, XS) → SND(splitAt(N, XS))
TAIL(cons(N, XS)) → ISLNAT(XS)
FST(pair(X, Y)) → AND(isLNat(X), isLNat(Y))
SND(pair(X, Y)) → ISLNAT(Y)
ISLNAT(tail(V1)) → ISLNAT(V1)
ISLNAT(take(V1, V2)) → ISNATURAL(V1)
FST(pair(X, Y)) → ISLNAT(X)
AFTERNTH(N, XS) → ISNATURAL(N)
NATSFROM(N) → U411(isNatural(N), N)
SPLITAT(s(N), cons(X, XS)) → ISNATURAL(N)
HEAD(cons(N, XS)) → U311(and(isNatural(N), isLNat(XS)), N)
SPLITAT(s(N), cons(X, XS)) → ISLNAT(XS)
ISLNAT(afterNth(V1, V2)) → ISNATURAL(V1)

The TRS R consists of the following rules:

U101(tt, N, XS) → fst(splitAt(N, XS))
U11(tt, N, XS) → snd(splitAt(N, XS))
U21(tt, X) → X
U31(tt, N) → N
U41(tt, N) → cons(N, natsFrom(s(N)))
U51(tt, N, XS) → head(afterNth(N, XS))
U61(tt, Y) → Y
U71(tt, XS) → pair(nil, XS)
U81(tt, N, X, XS) → U82(splitAt(N, XS), X)
U82(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
U91(tt, XS) → XS
afterNth(N, XS) → U11(and(isNatural(N), isLNat(XS)), N, XS)
and(tt, X) → X
fst(pair(X, Y)) → U21(and(isLNat(X), isLNat(Y)), X)
head(cons(N, XS)) → U31(and(isNatural(N), isLNat(XS)), N)
isLNat(nil) → tt
isLNat(afterNth(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(cons(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(fst(V1)) → isPLNat(V1)
isLNat(natsFrom(V1)) → isNatural(V1)
isLNat(snd(V1)) → isPLNat(V1)
isLNat(tail(V1)) → isLNat(V1)
isLNat(take(V1, V2)) → and(isNatural(V1), isLNat(V2))
isNatural(0) → tt
isNatural(head(V1)) → isLNat(V1)
isNatural(s(V1)) → isNatural(V1)
isNatural(sel(V1, V2)) → and(isNatural(V1), isLNat(V2))
isPLNat(pair(V1, V2)) → and(isLNat(V1), isLNat(V2))
isPLNat(splitAt(V1, V2)) → and(isNatural(V1), isLNat(V2))
natsFrom(N) → U41(isNatural(N), N)
sel(N, XS) → U51(and(isNatural(N), isLNat(XS)), N, XS)
snd(pair(X, Y)) → U61(and(isLNat(X), isLNat(Y)), Y)
splitAt(0, XS) → U71(isLNat(XS), XS)
splitAt(s(N), cons(X, XS)) → U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tail(cons(N, XS)) → U91(and(isNatural(N), isLNat(XS)), XS)
take(N, XS) → U101(and(isNatural(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

ISLNAT(cons(V1, V2)) → ISNATURAL(V1)
SPLITAT(s(N), cons(X, XS)) → AND(isNatural(N), and(isNatural(X), isLNat(XS)))
SEL(N, XS) → U511(and(isNatural(N), isLNat(XS)), N, XS)
TAKE(N, XS) → ISLNAT(XS)
U511(tt, N, XS) → AFTERNTH(N, XS)
ISLNAT(cons(V1, V2)) → ISLNAT(V2)
AFTERNTH(N, XS) → U111(and(isNatural(N), isLNat(XS)), N, XS)
U1011(tt, N, XS) → SPLITAT(N, XS)
TAIL(cons(N, XS)) → U911(and(isNatural(N), isLNat(XS)), XS)
ISPLNAT(splitAt(V1, V2)) → AND(isNatural(V1), isLNat(V2))
SPLITAT(s(N), cons(X, XS)) → ISNATURAL(X)
NATSFROM(N) → ISNATURAL(N)
TAKE(N, XS) → U1011(and(isNatural(N), isLNat(XS)), N, XS)
SPLITAT(0, XS) → U711(isLNat(XS), XS)
AFTERNTH(N, XS) → AND(isNatural(N), isLNat(XS))
TAKE(N, XS) → ISNATURAL(N)
FST(pair(X, Y)) → U211(and(isLNat(X), isLNat(Y)), X)
ISNATURAL(sel(V1, V2)) → ISNATURAL(V1)
ISPLNAT(pair(V1, V2)) → ISLNAT(V2)
TAKE(N, XS) → AND(isNatural(N), isLNat(XS))
U811(tt, N, X, XS) → SPLITAT(N, XS)
SPLITAT(s(N), cons(X, XS)) → U811(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS)
U511(tt, N, XS) → HEAD(afterNth(N, XS))
ISLNAT(take(V1, V2)) → AND(isNatural(V1), isLNat(V2))
ISLNAT(snd(V1)) → ISPLNAT(V1)
U111(tt, N, XS) → SPLITAT(N, XS)
ISNATURAL(s(V1)) → ISNATURAL(V1)
SND(pair(X, Y)) → AND(isLNat(X), isLNat(Y))
ISPLNAT(pair(V1, V2)) → ISLNAT(V1)
SEL(N, XS) → AND(isNatural(N), isLNat(XS))
HEAD(cons(N, XS)) → ISNATURAL(N)
ISNATURAL(head(V1)) → ISLNAT(V1)
SND(pair(X, Y)) → U611(and(isLNat(X), isLNat(Y)), Y)
SPLITAT(s(N), cons(X, XS)) → AND(isNatural(X), isLNat(XS))
ISLNAT(afterNth(V1, V2)) → AND(isNatural(V1), isLNat(V2))
SND(pair(X, Y)) → ISLNAT(X)
ISNATURAL(sel(V1, V2)) → AND(isNatural(V1), isLNat(V2))
HEAD(cons(N, XS)) → AND(isNatural(N), isLNat(XS))
ISPLNAT(splitAt(V1, V2)) → ISLNAT(V2)
ISLNAT(afterNth(V1, V2)) → ISLNAT(V2)
TAIL(cons(N, XS)) → ISNATURAL(N)
TAIL(cons(N, XS)) → AND(isNatural(N), isLNat(XS))
AFTERNTH(N, XS) → ISLNAT(XS)
SPLITAT(0, XS) → ISLNAT(XS)
U1011(tt, N, XS) → FST(splitAt(N, XS))
HEAD(cons(N, XS)) → ISLNAT(XS)
U411(tt, N) → NATSFROM(s(N))
ISNATURAL(sel(V1, V2)) → ISLNAT(V2)
ISPLNAT(pair(V1, V2)) → AND(isLNat(V1), isLNat(V2))
SEL(N, XS) → ISNATURAL(N)
ISLNAT(natsFrom(V1)) → ISNATURAL(V1)
FST(pair(X, Y)) → ISLNAT(Y)
ISLNAT(fst(V1)) → ISPLNAT(V1)
ISLNAT(cons(V1, V2)) → AND(isNatural(V1), isLNat(V2))
U811(tt, N, X, XS) → U821(splitAt(N, XS), X)
ISLNAT(take(V1, V2)) → ISLNAT(V2)
ISPLNAT(splitAt(V1, V2)) → ISNATURAL(V1)
SEL(N, XS) → ISLNAT(XS)
U111(tt, N, XS) → SND(splitAt(N, XS))
TAIL(cons(N, XS)) → ISLNAT(XS)
FST(pair(X, Y)) → AND(isLNat(X), isLNat(Y))
SND(pair(X, Y)) → ISLNAT(Y)
ISLNAT(tail(V1)) → ISLNAT(V1)
ISLNAT(take(V1, V2)) → ISNATURAL(V1)
FST(pair(X, Y)) → ISLNAT(X)
AFTERNTH(N, XS) → ISNATURAL(N)
NATSFROM(N) → U411(isNatural(N), N)
SPLITAT(s(N), cons(X, XS)) → ISNATURAL(N)
HEAD(cons(N, XS)) → U311(and(isNatural(N), isLNat(XS)), N)
SPLITAT(s(N), cons(X, XS)) → ISLNAT(XS)
ISLNAT(afterNth(V1, V2)) → ISNATURAL(V1)

The TRS R consists of the following rules:

U101(tt, N, XS) → fst(splitAt(N, XS))
U11(tt, N, XS) → snd(splitAt(N, XS))
U21(tt, X) → X
U31(tt, N) → N
U41(tt, N) → cons(N, natsFrom(s(N)))
U51(tt, N, XS) → head(afterNth(N, XS))
U61(tt, Y) → Y
U71(tt, XS) → pair(nil, XS)
U81(tt, N, X, XS) → U82(splitAt(N, XS), X)
U82(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
U91(tt, XS) → XS
afterNth(N, XS) → U11(and(isNatural(N), isLNat(XS)), N, XS)
and(tt, X) → X
fst(pair(X, Y)) → U21(and(isLNat(X), isLNat(Y)), X)
head(cons(N, XS)) → U31(and(isNatural(N), isLNat(XS)), N)
isLNat(nil) → tt
isLNat(afterNth(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(cons(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(fst(V1)) → isPLNat(V1)
isLNat(natsFrom(V1)) → isNatural(V1)
isLNat(snd(V1)) → isPLNat(V1)
isLNat(tail(V1)) → isLNat(V1)
isLNat(take(V1, V2)) → and(isNatural(V1), isLNat(V2))
isNatural(0) → tt
isNatural(head(V1)) → isLNat(V1)
isNatural(s(V1)) → isNatural(V1)
isNatural(sel(V1, V2)) → and(isNatural(V1), isLNat(V2))
isPLNat(pair(V1, V2)) → and(isLNat(V1), isLNat(V2))
isPLNat(splitAt(V1, V2)) → and(isNatural(V1), isLNat(V2))
natsFrom(N) → U41(isNatural(N), N)
sel(N, XS) → U51(and(isNatural(N), isLNat(XS)), N, XS)
snd(pair(X, Y)) → U61(and(isLNat(X), isLNat(Y)), Y)
splitAt(0, XS) → U71(isLNat(XS), XS)
splitAt(s(N), cons(X, XS)) → U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tail(cons(N, XS)) → U91(and(isNatural(N), isLNat(XS)), XS)
take(N, XS) → U101(and(isNatural(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 3 SCCs with 49 less nodes.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
                ↳ UsableRulesProof
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ISLNAT(cons(V1, V2)) → ISNATURAL(V1)
ISLNAT(natsFrom(V1)) → ISNATURAL(V1)
ISLNAT(fst(V1)) → ISPLNAT(V1)
ISNATURAL(sel(V1, V2)) → ISNATURAL(V1)
ISPLNAT(splitAt(V1, V2)) → ISLNAT(V2)
ISLNAT(cons(V1, V2)) → ISLNAT(V2)
ISPLNAT(pair(V1, V2)) → ISLNAT(V2)
ISPLNAT(splitAt(V1, V2)) → ISNATURAL(V1)
ISLNAT(take(V1, V2)) → ISLNAT(V2)
ISLNAT(afterNth(V1, V2)) → ISLNAT(V2)
ISLNAT(tail(V1)) → ISLNAT(V1)
ISLNAT(snd(V1)) → ISPLNAT(V1)
ISLNAT(take(V1, V2)) → ISNATURAL(V1)
ISNATURAL(s(V1)) → ISNATURAL(V1)
ISPLNAT(pair(V1, V2)) → ISLNAT(V1)
ISNATURAL(head(V1)) → ISLNAT(V1)
ISNATURAL(sel(V1, V2)) → ISLNAT(V2)
ISLNAT(afterNth(V1, V2)) → ISNATURAL(V1)

The TRS R consists of the following rules:

U101(tt, N, XS) → fst(splitAt(N, XS))
U11(tt, N, XS) → snd(splitAt(N, XS))
U21(tt, X) → X
U31(tt, N) → N
U41(tt, N) → cons(N, natsFrom(s(N)))
U51(tt, N, XS) → head(afterNth(N, XS))
U61(tt, Y) → Y
U71(tt, XS) → pair(nil, XS)
U81(tt, N, X, XS) → U82(splitAt(N, XS), X)
U82(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
U91(tt, XS) → XS
afterNth(N, XS) → U11(and(isNatural(N), isLNat(XS)), N, XS)
and(tt, X) → X
fst(pair(X, Y)) → U21(and(isLNat(X), isLNat(Y)), X)
head(cons(N, XS)) → U31(and(isNatural(N), isLNat(XS)), N)
isLNat(nil) → tt
isLNat(afterNth(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(cons(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(fst(V1)) → isPLNat(V1)
isLNat(natsFrom(V1)) → isNatural(V1)
isLNat(snd(V1)) → isPLNat(V1)
isLNat(tail(V1)) → isLNat(V1)
isLNat(take(V1, V2)) → and(isNatural(V1), isLNat(V2))
isNatural(0) → tt
isNatural(head(V1)) → isLNat(V1)
isNatural(s(V1)) → isNatural(V1)
isNatural(sel(V1, V2)) → and(isNatural(V1), isLNat(V2))
isPLNat(pair(V1, V2)) → and(isLNat(V1), isLNat(V2))
isPLNat(splitAt(V1, V2)) → and(isNatural(V1), isLNat(V2))
natsFrom(N) → U41(isNatural(N), N)
sel(N, XS) → U51(and(isNatural(N), isLNat(XS)), N, XS)
snd(pair(X, Y)) → U61(and(isLNat(X), isLNat(Y)), Y)
splitAt(0, XS) → U71(isLNat(XS), XS)
splitAt(s(N), cons(X, XS)) → U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tail(cons(N, XS)) → U91(and(isNatural(N), isLNat(XS)), XS)
take(N, XS) → U101(and(isNatural(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We can use the usable rules and reduction pair processor [15] with the Ce-compatible extension of the polynomial order that maps every function symbol to the sum of its argument. Then, we can delete all non-usable rules [17] from R.

↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QDPSizeChangeProof
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ISLNAT(cons(V1, V2)) → ISNATURAL(V1)
ISLNAT(natsFrom(V1)) → ISNATURAL(V1)
ISLNAT(fst(V1)) → ISPLNAT(V1)
ISNATURAL(sel(V1, V2)) → ISNATURAL(V1)
ISPLNAT(splitAt(V1, V2)) → ISLNAT(V2)
ISLNAT(cons(V1, V2)) → ISLNAT(V2)
ISPLNAT(pair(V1, V2)) → ISLNAT(V2)
ISPLNAT(splitAt(V1, V2)) → ISNATURAL(V1)
ISLNAT(take(V1, V2)) → ISLNAT(V2)
ISLNAT(afterNth(V1, V2)) → ISLNAT(V2)
ISLNAT(tail(V1)) → ISLNAT(V1)
ISLNAT(snd(V1)) → ISPLNAT(V1)
ISLNAT(take(V1, V2)) → ISNATURAL(V1)
ISNATURAL(s(V1)) → ISNATURAL(V1)
ISPLNAT(pair(V1, V2)) → ISLNAT(V1)
ISNATURAL(sel(V1, V2)) → ISLNAT(V2)
ISNATURAL(head(V1)) → ISLNAT(V1)
ISLNAT(afterNth(V1, V2)) → ISNATURAL(V1)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ QDPSizeChangeProof
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

U811(tt, N, X, XS) → SPLITAT(N, XS)
SPLITAT(s(N), cons(X, XS)) → U811(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS)

The TRS R consists of the following rules:

U101(tt, N, XS) → fst(splitAt(N, XS))
U11(tt, N, XS) → snd(splitAt(N, XS))
U21(tt, X) → X
U31(tt, N) → N
U41(tt, N) → cons(N, natsFrom(s(N)))
U51(tt, N, XS) → head(afterNth(N, XS))
U61(tt, Y) → Y
U71(tt, XS) → pair(nil, XS)
U81(tt, N, X, XS) → U82(splitAt(N, XS), X)
U82(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
U91(tt, XS) → XS
afterNth(N, XS) → U11(and(isNatural(N), isLNat(XS)), N, XS)
and(tt, X) → X
fst(pair(X, Y)) → U21(and(isLNat(X), isLNat(Y)), X)
head(cons(N, XS)) → U31(and(isNatural(N), isLNat(XS)), N)
isLNat(nil) → tt
isLNat(afterNth(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(cons(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(fst(V1)) → isPLNat(V1)
isLNat(natsFrom(V1)) → isNatural(V1)
isLNat(snd(V1)) → isPLNat(V1)
isLNat(tail(V1)) → isLNat(V1)
isLNat(take(V1, V2)) → and(isNatural(V1), isLNat(V2))
isNatural(0) → tt
isNatural(head(V1)) → isLNat(V1)
isNatural(s(V1)) → isNatural(V1)
isNatural(sel(V1, V2)) → and(isNatural(V1), isLNat(V2))
isPLNat(pair(V1, V2)) → and(isLNat(V1), isLNat(V2))
isPLNat(splitAt(V1, V2)) → and(isNatural(V1), isLNat(V2))
natsFrom(N) → U41(isNatural(N), N)
sel(N, XS) → U51(and(isNatural(N), isLNat(XS)), N, XS)
snd(pair(X, Y)) → U61(and(isLNat(X), isLNat(Y)), Y)
splitAt(0, XS) → U71(isLNat(XS), XS)
splitAt(s(N), cons(X, XS)) → U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tail(cons(N, XS)) → U91(and(isNatural(N), isLNat(XS)), XS)
take(N, XS) → U101(and(isNatural(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: 



↳ CSR
  ↳ CSDependencyPairsProof
  ↳ Incomplete Giesl Middeldorp-Transformation
  ↳ Trivial-Transformation
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

NATSFROM(N) → U411(isNatural(N), N)
U411(tt, N) → NATSFROM(s(N))

The TRS R consists of the following rules:

U101(tt, N, XS) → fst(splitAt(N, XS))
U11(tt, N, XS) → snd(splitAt(N, XS))
U21(tt, X) → X
U31(tt, N) → N
U41(tt, N) → cons(N, natsFrom(s(N)))
U51(tt, N, XS) → head(afterNth(N, XS))
U61(tt, Y) → Y
U71(tt, XS) → pair(nil, XS)
U81(tt, N, X, XS) → U82(splitAt(N, XS), X)
U82(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
U91(tt, XS) → XS
afterNth(N, XS) → U11(and(isNatural(N), isLNat(XS)), N, XS)
and(tt, X) → X
fst(pair(X, Y)) → U21(and(isLNat(X), isLNat(Y)), X)
head(cons(N, XS)) → U31(and(isNatural(N), isLNat(XS)), N)
isLNat(nil) → tt
isLNat(afterNth(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(cons(V1, V2)) → and(isNatural(V1), isLNat(V2))
isLNat(fst(V1)) → isPLNat(V1)
isLNat(natsFrom(V1)) → isNatural(V1)
isLNat(snd(V1)) → isPLNat(V1)
isLNat(tail(V1)) → isLNat(V1)
isLNat(take(V1, V2)) → and(isNatural(V1), isLNat(V2))
isNatural(0) → tt
isNatural(head(V1)) → isLNat(V1)
isNatural(s(V1)) → isNatural(V1)
isNatural(sel(V1, V2)) → and(isNatural(V1), isLNat(V2))
isPLNat(pair(V1, V2)) → and(isLNat(V1), isLNat(V2))
isPLNat(splitAt(V1, V2)) → and(isNatural(V1), isLNat(V2))
natsFrom(N) → U41(isNatural(N), N)
sel(N, XS) → U51(and(isNatural(N), isLNat(XS)), N, XS)
snd(pair(X, Y)) → U61(and(isLNat(X), isLNat(Y)), Y)
splitAt(0, XS) → U71(isLNat(XS), XS)
splitAt(s(N), cons(X, XS)) → U81(and(isNatural(N), and(isNatural(X), isLNat(XS))), N, X, XS)
tail(cons(N, XS)) → U91(and(isNatural(N), isLNat(XS)), XS)
take(N, XS) → U101(and(isNatural(N), isLNat(XS)), N, XS)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.